#![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 SiteServerUI_Login_Request {
username: ::protobuf::SingularField<::std::string::String>,
password: ::protobuf::SingularField<::std::string::String>,
steamguardcode: ::protobuf::SingularField<::std::string::String>,
remember_password: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Login_Request {
fn default() -> &'a SiteServerUI_Login_Request {
<SiteServerUI_Login_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Login_Request {
pub fn new() -> SiteServerUI_Login_Request {
::std::default::Default::default()
}
pub fn get_username(&self) -> &str {
match self.username.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_username(&mut self) {
self.username.clear();
}
pub fn has_username(&self) -> bool {
self.username.is_some()
}
pub fn set_username(&mut self, v: ::std::string::String) {
self.username = ::protobuf::SingularField::some(v);
}
pub fn mut_username(&mut self) -> &mut ::std::string::String {
if self.username.is_none() {
self.username.set_default();
}
self.username.as_mut().unwrap()
}
pub fn take_username(&mut self) -> ::std::string::String {
self.username.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_password(&self) -> &str {
match self.password.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_password(&mut self) {
self.password.clear();
}
pub fn has_password(&self) -> bool {
self.password.is_some()
}
pub fn set_password(&mut self, v: ::std::string::String) {
self.password = ::protobuf::SingularField::some(v);
}
pub fn mut_password(&mut self) -> &mut ::std::string::String {
if self.password.is_none() {
self.password.set_default();
}
self.password.as_mut().unwrap()
}
pub fn take_password(&mut self) -> ::std::string::String {
self.password.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_steamguardcode(&self) -> &str {
match self.steamguardcode.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_steamguardcode(&mut self) {
self.steamguardcode.clear();
}
pub fn has_steamguardcode(&self) -> bool {
self.steamguardcode.is_some()
}
pub fn set_steamguardcode(&mut self, v: ::std::string::String) {
self.steamguardcode = ::protobuf::SingularField::some(v);
}
pub fn mut_steamguardcode(&mut self) -> &mut ::std::string::String {
if self.steamguardcode.is_none() {
self.steamguardcode.set_default();
}
self.steamguardcode.as_mut().unwrap()
}
pub fn take_steamguardcode(&mut self) -> ::std::string::String {
self.steamguardcode.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_remember_password(&self) -> bool {
self.remember_password.unwrap_or(false)
}
pub fn clear_remember_password(&mut self) {
self.remember_password = ::std::option::Option::None;
}
pub fn has_remember_password(&self) -> bool {
self.remember_password.is_some()
}
pub fn set_remember_password(&mut self, v: bool) {
self.remember_password = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_Login_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 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.username)?;
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.password)?;
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.steamguardcode)?;
},
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.remember_password = ::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(ref v) = self.username.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(ref v) = self.password.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(ref v) = self.steamguardcode.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.remember_password {
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(ref v) = self.username.as_ref() {
os.write_string(1, &v)?;
}
if let Some(ref v) = self.password.as_ref() {
os.write_string(2, &v)?;
}
if let Some(ref v) = self.steamguardcode.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.remember_password {
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() -> SiteServerUI_Login_Request {
SiteServerUI_Login_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"username",
|m: &SiteServerUI_Login_Request| { &m.username },
|m: &mut SiteServerUI_Login_Request| { &mut m.username },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"password",
|m: &SiteServerUI_Login_Request| { &m.password },
|m: &mut SiteServerUI_Login_Request| { &mut m.password },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"steamguardcode",
|m: &SiteServerUI_Login_Request| { &m.steamguardcode },
|m: &mut SiteServerUI_Login_Request| { &mut m.steamguardcode },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"remember_password",
|m: &SiteServerUI_Login_Request| { &m.remember_password },
|m: &mut SiteServerUI_Login_Request| { &mut m.remember_password },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_Login_Request>(
"SiteServerUI_Login_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Login_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Login_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Login_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Login_Request {
fn clear(&mut self) {
self.username.clear();
self.password.clear();
self.steamguardcode.clear();
self.remember_password = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Login_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Login_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Login_Response {
logon_state: ::std::option::Option<i32>,
logon_eresult: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Login_Response {
fn default() -> &'a SiteServerUI_Login_Response {
<SiteServerUI_Login_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Login_Response {
pub fn new() -> SiteServerUI_Login_Response {
::std::default::Default::default()
}
pub fn get_logon_state(&self) -> i32 {
self.logon_state.unwrap_or(0)
}
pub fn clear_logon_state(&mut self) {
self.logon_state = ::std::option::Option::None;
}
pub fn has_logon_state(&self) -> bool {
self.logon_state.is_some()
}
pub fn set_logon_state(&mut self, v: i32) {
self.logon_state = ::std::option::Option::Some(v);
}
pub fn get_logon_eresult(&self) -> i32 {
self.logon_eresult.unwrap_or(0)
}
pub fn clear_logon_eresult(&mut self) {
self.logon_eresult = ::std::option::Option::None;
}
pub fn has_logon_eresult(&self) -> bool {
self.logon_eresult.is_some()
}
pub fn set_logon_eresult(&mut self, v: i32) {
self.logon_eresult = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_Login_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_int32()?;
self.logon_state = ::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.logon_eresult = ::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.logon_state {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.logon_eresult {
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.logon_state {
os.write_int32(1, v)?;
}
if let Some(v) = self.logon_eresult {
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() -> SiteServerUI_Login_Response {
SiteServerUI_Login_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::ProtobufTypeInt32>(
"logon_state",
|m: &SiteServerUI_Login_Response| { &m.logon_state },
|m: &mut SiteServerUI_Login_Response| { &mut m.logon_state },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"logon_eresult",
|m: &SiteServerUI_Login_Response| { &m.logon_eresult },
|m: &mut SiteServerUI_Login_Response| { &mut m.logon_eresult },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_Login_Response>(
"SiteServerUI_Login_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Login_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Login_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Login_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Login_Response {
fn clear(&mut self) {
self.logon_state = ::std::option::Option::None;
self.logon_eresult = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Login_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Login_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_LoginStatus_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_LoginStatus_Request {
fn default() -> &'a SiteServerUI_LoginStatus_Request {
<SiteServerUI_LoginStatus_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_LoginStatus_Request {
pub fn new() -> SiteServerUI_LoginStatus_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_LoginStatus_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() -> SiteServerUI_LoginStatus_Request {
SiteServerUI_LoginStatus_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::<SiteServerUI_LoginStatus_Request>(
"SiteServerUI_LoginStatus_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_LoginStatus_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_LoginStatus_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_LoginStatus_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_LoginStatus_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_LoginStatus_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_LoginStatus_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_LoginStatus_Response {
username: ::protobuf::SingularField<::std::string::String>,
cached_credentials: ::std::option::Option<bool>,
logon_state: ::std::option::Option<i32>,
logon_eresult: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_LoginStatus_Response {
fn default() -> &'a SiteServerUI_LoginStatus_Response {
<SiteServerUI_LoginStatus_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_LoginStatus_Response {
pub fn new() -> SiteServerUI_LoginStatus_Response {
::std::default::Default::default()
}
pub fn get_username(&self) -> &str {
match self.username.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_username(&mut self) {
self.username.clear();
}
pub fn has_username(&self) -> bool {
self.username.is_some()
}
pub fn set_username(&mut self, v: ::std::string::String) {
self.username = ::protobuf::SingularField::some(v);
}
pub fn mut_username(&mut self) -> &mut ::std::string::String {
if self.username.is_none() {
self.username.set_default();
}
self.username.as_mut().unwrap()
}
pub fn take_username(&mut self) -> ::std::string::String {
self.username.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_cached_credentials(&self) -> bool {
self.cached_credentials.unwrap_or(false)
}
pub fn clear_cached_credentials(&mut self) {
self.cached_credentials = ::std::option::Option::None;
}
pub fn has_cached_credentials(&self) -> bool {
self.cached_credentials.is_some()
}
pub fn set_cached_credentials(&mut self, v: bool) {
self.cached_credentials = ::std::option::Option::Some(v);
}
pub fn get_logon_state(&self) -> i32 {
self.logon_state.unwrap_or(0)
}
pub fn clear_logon_state(&mut self) {
self.logon_state = ::std::option::Option::None;
}
pub fn has_logon_state(&self) -> bool {
self.logon_state.is_some()
}
pub fn set_logon_state(&mut self, v: i32) {
self.logon_state = ::std::option::Option::Some(v);
}
pub fn get_logon_eresult(&self) -> i32 {
self.logon_eresult.unwrap_or(0)
}
pub fn clear_logon_eresult(&mut self) {
self.logon_eresult = ::std::option::Option::None;
}
pub fn has_logon_eresult(&self) -> bool {
self.logon_eresult.is_some()
}
pub fn set_logon_eresult(&mut self, v: i32) {
self.logon_eresult = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_LoginStatus_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.username)?;
},
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.cached_credentials = ::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_int32()?;
self.logon_state = ::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.logon_eresult = ::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(ref v) = self.username.as_ref() {
my_size += ::protobuf::rt::string_size(1, &v);
}
if let Some(v) = self.cached_credentials {
my_size += 2;
}
if let Some(v) = self.logon_state {
my_size += ::protobuf::rt::value_size(3, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.logon_eresult {
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(ref v) = self.username.as_ref() {
os.write_string(1, &v)?;
}
if let Some(v) = self.cached_credentials {
os.write_bool(2, v)?;
}
if let Some(v) = self.logon_state {
os.write_int32(3, v)?;
}
if let Some(v) = self.logon_eresult {
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() -> SiteServerUI_LoginStatus_Response {
SiteServerUI_LoginStatus_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>(
"username",
|m: &SiteServerUI_LoginStatus_Response| { &m.username },
|m: &mut SiteServerUI_LoginStatus_Response| { &mut m.username },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"cached_credentials",
|m: &SiteServerUI_LoginStatus_Response| { &m.cached_credentials },
|m: &mut SiteServerUI_LoginStatus_Response| { &mut m.cached_credentials },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"logon_state",
|m: &SiteServerUI_LoginStatus_Response| { &m.logon_state },
|m: &mut SiteServerUI_LoginStatus_Response| { &mut m.logon_state },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"logon_eresult",
|m: &SiteServerUI_LoginStatus_Response| { &m.logon_eresult },
|m: &mut SiteServerUI_LoginStatus_Response| { &mut m.logon_eresult },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_LoginStatus_Response>(
"SiteServerUI_LoginStatus_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_LoginStatus_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_LoginStatus_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_LoginStatus_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_LoginStatus_Response {
fn clear(&mut self) {
self.username.clear();
self.cached_credentials = ::std::option::Option::None;
self.logon_state = ::std::option::Option::None;
self.logon_eresult = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_LoginStatus_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_LoginStatus_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_CancelLogin_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_CancelLogin_Request {
fn default() -> &'a SiteServerUI_CancelLogin_Request {
<SiteServerUI_CancelLogin_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_CancelLogin_Request {
pub fn new() -> SiteServerUI_CancelLogin_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_CancelLogin_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() -> SiteServerUI_CancelLogin_Request {
SiteServerUI_CancelLogin_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::<SiteServerUI_CancelLogin_Request>(
"SiteServerUI_CancelLogin_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_CancelLogin_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_CancelLogin_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_CancelLogin_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_CancelLogin_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_CancelLogin_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_CancelLogin_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_CancelLogin_Response {
logon_state: ::std::option::Option<i32>,
logon_eresult: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_CancelLogin_Response {
fn default() -> &'a SiteServerUI_CancelLogin_Response {
<SiteServerUI_CancelLogin_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_CancelLogin_Response {
pub fn new() -> SiteServerUI_CancelLogin_Response {
::std::default::Default::default()
}
pub fn get_logon_state(&self) -> i32 {
self.logon_state.unwrap_or(0)
}
pub fn clear_logon_state(&mut self) {
self.logon_state = ::std::option::Option::None;
}
pub fn has_logon_state(&self) -> bool {
self.logon_state.is_some()
}
pub fn set_logon_state(&mut self, v: i32) {
self.logon_state = ::std::option::Option::Some(v);
}
pub fn get_logon_eresult(&self) -> i32 {
self.logon_eresult.unwrap_or(0)
}
pub fn clear_logon_eresult(&mut self) {
self.logon_eresult = ::std::option::Option::None;
}
pub fn has_logon_eresult(&self) -> bool {
self.logon_eresult.is_some()
}
pub fn set_logon_eresult(&mut self, v: i32) {
self.logon_eresult = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_CancelLogin_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_int32()?;
self.logon_state = ::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.logon_eresult = ::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.logon_state {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.logon_eresult {
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.logon_state {
os.write_int32(1, v)?;
}
if let Some(v) = self.logon_eresult {
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() -> SiteServerUI_CancelLogin_Response {
SiteServerUI_CancelLogin_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::ProtobufTypeInt32>(
"logon_state",
|m: &SiteServerUI_CancelLogin_Response| { &m.logon_state },
|m: &mut SiteServerUI_CancelLogin_Response| { &mut m.logon_state },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"logon_eresult",
|m: &SiteServerUI_CancelLogin_Response| { &m.logon_eresult },
|m: &mut SiteServerUI_CancelLogin_Response| { &mut m.logon_eresult },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_CancelLogin_Response>(
"SiteServerUI_CancelLogin_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_CancelLogin_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_CancelLogin_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_CancelLogin_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_CancelLogin_Response {
fn clear(&mut self) {
self.logon_state = ::std::option::Option::None;
self.logon_eresult = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_CancelLogin_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_CancelLogin_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Logout_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Logout_Request {
fn default() -> &'a SiteServerUI_Logout_Request {
<SiteServerUI_Logout_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Logout_Request {
pub fn new() -> SiteServerUI_Logout_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_Logout_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() -> SiteServerUI_Logout_Request {
SiteServerUI_Logout_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::<SiteServerUI_Logout_Request>(
"SiteServerUI_Logout_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Logout_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Logout_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Logout_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Logout_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Logout_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Logout_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Logout_Response {
logon_state: ::std::option::Option<i32>,
logout_eresult: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Logout_Response {
fn default() -> &'a SiteServerUI_Logout_Response {
<SiteServerUI_Logout_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Logout_Response {
pub fn new() -> SiteServerUI_Logout_Response {
::std::default::Default::default()
}
pub fn get_logon_state(&self) -> i32 {
self.logon_state.unwrap_or(0)
}
pub fn clear_logon_state(&mut self) {
self.logon_state = ::std::option::Option::None;
}
pub fn has_logon_state(&self) -> bool {
self.logon_state.is_some()
}
pub fn set_logon_state(&mut self, v: i32) {
self.logon_state = ::std::option::Option::Some(v);
}
pub fn get_logout_eresult(&self) -> i32 {
self.logout_eresult.unwrap_or(0)
}
pub fn clear_logout_eresult(&mut self) {
self.logout_eresult = ::std::option::Option::None;
}
pub fn has_logout_eresult(&self) -> bool {
self.logout_eresult.is_some()
}
pub fn set_logout_eresult(&mut self, v: i32) {
self.logout_eresult = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_Logout_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_int32()?;
self.logon_state = ::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.logout_eresult = ::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.logon_state {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.logout_eresult {
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.logon_state {
os.write_int32(1, v)?;
}
if let Some(v) = self.logout_eresult {
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() -> SiteServerUI_Logout_Response {
SiteServerUI_Logout_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::ProtobufTypeInt32>(
"logon_state",
|m: &SiteServerUI_Logout_Response| { &m.logon_state },
|m: &mut SiteServerUI_Logout_Response| { &mut m.logon_state },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"logout_eresult",
|m: &SiteServerUI_Logout_Response| { &m.logout_eresult },
|m: &mut SiteServerUI_Logout_Response| { &mut m.logout_eresult },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_Logout_Response>(
"SiteServerUI_Logout_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Logout_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Logout_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Logout_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Logout_Response {
fn clear(&mut self) {
self.logon_state = ::std::option::Option::None;
self.logout_eresult = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Logout_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Logout_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Quit_Request {
restart: ::std::option::Option<bool>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Quit_Request {
fn default() -> &'a SiteServerUI_Quit_Request {
<SiteServerUI_Quit_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Quit_Request {
pub fn new() -> SiteServerUI_Quit_Request {
::std::default::Default::default()
}
pub fn get_restart(&self) -> bool {
self.restart.unwrap_or(false)
}
pub fn clear_restart(&mut self) {
self.restart = ::std::option::Option::None;
}
pub fn has_restart(&self) -> bool {
self.restart.is_some()
}
pub fn set_restart(&mut self, v: bool) {
self.restart = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_Quit_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_bool()?;
self.restart = ::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.restart {
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.restart {
os.write_bool(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() -> SiteServerUI_Quit_Request {
SiteServerUI_Quit_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::ProtobufTypeBool>(
"restart",
|m: &SiteServerUI_Quit_Request| { &m.restart },
|m: &mut SiteServerUI_Quit_Request| { &mut m.restart },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_Quit_Request>(
"SiteServerUI_Quit_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Quit_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Quit_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Quit_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Quit_Request {
fn clear(&mut self) {
self.restart = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Quit_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Quit_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Quit_Response {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Quit_Response {
fn default() -> &'a SiteServerUI_Quit_Response {
<SiteServerUI_Quit_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Quit_Response {
pub fn new() -> SiteServerUI_Quit_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_Quit_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() -> SiteServerUI_Quit_Response {
SiteServerUI_Quit_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::<SiteServerUI_Quit_Response>(
"SiteServerUI_Quit_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Quit_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Quit_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Quit_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Quit_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Quit_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Quit_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Status_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Status_Request {
fn default() -> &'a SiteServerUI_Status_Request {
<SiteServerUI_Status_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Status_Request {
pub fn new() -> SiteServerUI_Status_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_Status_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() -> SiteServerUI_Status_Request {
SiteServerUI_Status_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::<SiteServerUI_Status_Request>(
"SiteServerUI_Status_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Status_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Status_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Status_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Status_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Status_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Status_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_Status_Response {
logon_state: ::std::option::Option<i32>,
logon_eresult: ::std::option::Option<i32>,
connected: ::std::option::Option<bool>,
cache_enabled: ::std::option::Option<bool>,
acct_status: ::std::option::Option<i32>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_Status_Response {
fn default() -> &'a SiteServerUI_Status_Response {
<SiteServerUI_Status_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_Status_Response {
pub fn new() -> SiteServerUI_Status_Response {
::std::default::Default::default()
}
pub fn get_logon_state(&self) -> i32 {
self.logon_state.unwrap_or(0)
}
pub fn clear_logon_state(&mut self) {
self.logon_state = ::std::option::Option::None;
}
pub fn has_logon_state(&self) -> bool {
self.logon_state.is_some()
}
pub fn set_logon_state(&mut self, v: i32) {
self.logon_state = ::std::option::Option::Some(v);
}
pub fn get_logon_eresult(&self) -> i32 {
self.logon_eresult.unwrap_or(0)
}
pub fn clear_logon_eresult(&mut self) {
self.logon_eresult = ::std::option::Option::None;
}
pub fn has_logon_eresult(&self) -> bool {
self.logon_eresult.is_some()
}
pub fn set_logon_eresult(&mut self, v: i32) {
self.logon_eresult = ::std::option::Option::Some(v);
}
pub fn get_connected(&self) -> bool {
self.connected.unwrap_or(false)
}
pub fn clear_connected(&mut self) {
self.connected = ::std::option::Option::None;
}
pub fn has_connected(&self) -> bool {
self.connected.is_some()
}
pub fn set_connected(&mut self, v: bool) {
self.connected = ::std::option::Option::Some(v);
}
pub fn get_cache_enabled(&self) -> bool {
self.cache_enabled.unwrap_or(false)
}
pub fn clear_cache_enabled(&mut self) {
self.cache_enabled = ::std::option::Option::None;
}
pub fn has_cache_enabled(&self) -> bool {
self.cache_enabled.is_some()
}
pub fn set_cache_enabled(&mut self, v: bool) {
self.cache_enabled = ::std::option::Option::Some(v);
}
pub fn get_acct_status(&self) -> i32 {
self.acct_status.unwrap_or(0)
}
pub fn clear_acct_status(&mut self) {
self.acct_status = ::std::option::Option::None;
}
pub fn has_acct_status(&self) -> bool {
self.acct_status.is_some()
}
pub fn set_acct_status(&mut self, v: i32) {
self.acct_status = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_Status_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_int32()?;
self.logon_state = ::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.logon_eresult = ::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.connected = ::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.cache_enabled = ::std::option::Option::Some(tmp);
},
5 => {
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.acct_status = ::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.logon_state {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.logon_eresult {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.connected {
my_size += 2;
}
if let Some(v) = self.cache_enabled {
my_size += 2;
}
if let Some(v) = self.acct_status {
my_size += ::protobuf::rt::value_size(5, 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.logon_state {
os.write_int32(1, v)?;
}
if let Some(v) = self.logon_eresult {
os.write_int32(2, v)?;
}
if let Some(v) = self.connected {
os.write_bool(3, v)?;
}
if let Some(v) = self.cache_enabled {
os.write_bool(4, v)?;
}
if let Some(v) = self.acct_status {
os.write_int32(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() -> SiteServerUI_Status_Response {
SiteServerUI_Status_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::ProtobufTypeInt32>(
"logon_state",
|m: &SiteServerUI_Status_Response| { &m.logon_state },
|m: &mut SiteServerUI_Status_Response| { &mut m.logon_state },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"logon_eresult",
|m: &SiteServerUI_Status_Response| { &m.logon_eresult },
|m: &mut SiteServerUI_Status_Response| { &mut m.logon_eresult },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"connected",
|m: &SiteServerUI_Status_Response| { &m.connected },
|m: &mut SiteServerUI_Status_Response| { &mut m.connected },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"cache_enabled",
|m: &SiteServerUI_Status_Response| { &m.cache_enabled },
|m: &mut SiteServerUI_Status_Response| { &mut m.cache_enabled },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"acct_status",
|m: &SiteServerUI_Status_Response| { &m.acct_status },
|m: &mut SiteServerUI_Status_Response| { &mut m.acct_status },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_Status_Response>(
"SiteServerUI_Status_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_Status_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_Status_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_Status_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_Status_Response {
fn clear(&mut self) {
self.logon_state = ::std::option::Option::None;
self.logon_eresult = ::std::option::Option::None;
self.connected = ::std::option::Option::None;
self.cache_enabled = ::std::option::Option::None;
self.acct_status = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_Status_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_Status_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_GetLanguage_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_GetLanguage_Request {
fn default() -> &'a SiteServerUI_GetLanguage_Request {
<SiteServerUI_GetLanguage_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_GetLanguage_Request {
pub fn new() -> SiteServerUI_GetLanguage_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_GetLanguage_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() -> SiteServerUI_GetLanguage_Request {
SiteServerUI_GetLanguage_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::<SiteServerUI_GetLanguage_Request>(
"SiteServerUI_GetLanguage_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_GetLanguage_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_GetLanguage_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_GetLanguage_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_GetLanguage_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_GetLanguage_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_GetLanguage_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_GetLanguage_Response {
language: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_GetLanguage_Response {
fn default() -> &'a SiteServerUI_GetLanguage_Response {
<SiteServerUI_GetLanguage_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_GetLanguage_Response {
pub fn new() -> SiteServerUI_GetLanguage_Response {
::std::default::Default::default()
}
pub fn get_language(&self) -> &str {
match self.language.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_language(&mut self) {
self.language.clear();
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: ::std::string::String) {
self.language = ::protobuf::SingularField::some(v);
}
pub fn mut_language(&mut self) -> &mut ::std::string::String {
if self.language.is_none() {
self.language.set_default();
}
self.language.as_mut().unwrap()
}
pub fn take_language(&mut self) -> ::std::string::String {
self.language.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for SiteServerUI_GetLanguage_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.language)?;
},
_ => {
::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.language.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.language.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() -> SiteServerUI_GetLanguage_Response {
SiteServerUI_GetLanguage_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>(
"language",
|m: &SiteServerUI_GetLanguage_Response| { &m.language },
|m: &mut SiteServerUI_GetLanguage_Response| { &mut m.language },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_GetLanguage_Response>(
"SiteServerUI_GetLanguage_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_GetLanguage_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_GetLanguage_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_GetLanguage_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_GetLanguage_Response {
fn clear(&mut self) {
self.language.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_GetLanguage_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_GetLanguage_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_SetLanguage_Request {
language: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_SetLanguage_Request {
fn default() -> &'a SiteServerUI_SetLanguage_Request {
<SiteServerUI_SetLanguage_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_SetLanguage_Request {
pub fn new() -> SiteServerUI_SetLanguage_Request {
::std::default::Default::default()
}
pub fn get_language(&self) -> &str {
match self.language.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_language(&mut self) {
self.language.clear();
}
pub fn has_language(&self) -> bool {
self.language.is_some()
}
pub fn set_language(&mut self, v: ::std::string::String) {
self.language = ::protobuf::SingularField::some(v);
}
pub fn mut_language(&mut self) -> &mut ::std::string::String {
if self.language.is_none() {
self.language.set_default();
}
self.language.as_mut().unwrap()
}
pub fn take_language(&mut self) -> ::std::string::String {
self.language.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for SiteServerUI_SetLanguage_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 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.language)?;
},
_ => {
::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.language.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.language.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() -> SiteServerUI_SetLanguage_Request {
SiteServerUI_SetLanguage_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_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"language",
|m: &SiteServerUI_SetLanguage_Request| { &m.language },
|m: &mut SiteServerUI_SetLanguage_Request| { &mut m.language },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_SetLanguage_Request>(
"SiteServerUI_SetLanguage_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_SetLanguage_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_SetLanguage_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_SetLanguage_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_SetLanguage_Request {
fn clear(&mut self) {
self.language.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_SetLanguage_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_SetLanguage_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_SetLanguage_Response {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_SetLanguage_Response {
fn default() -> &'a SiteServerUI_SetLanguage_Response {
<SiteServerUI_SetLanguage_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_SetLanguage_Response {
pub fn new() -> SiteServerUI_SetLanguage_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_SetLanguage_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() -> SiteServerUI_SetLanguage_Response {
SiteServerUI_SetLanguage_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::<SiteServerUI_SetLanguage_Response>(
"SiteServerUI_SetLanguage_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_SetLanguage_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_SetLanguage_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_SetLanguage_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_SetLanguage_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_SetLanguage_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_SetLanguage_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ClientStatus_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ClientStatus_Request {
fn default() -> &'a SiteServerUI_ClientStatus_Request {
<SiteServerUI_ClientStatus_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ClientStatus_Request {
pub fn new() -> SiteServerUI_ClientStatus_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_ClientStatus_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() -> SiteServerUI_ClientStatus_Request {
SiteServerUI_ClientStatus_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::<SiteServerUI_ClientStatus_Request>(
"SiteServerUI_ClientStatus_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ClientStatus_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ClientStatus_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ClientStatus_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ClientStatus_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ClientStatus_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ClientStatus_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ClientStatus_Response {
pub clients: ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_ClientInfo>,
pub payments: ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_Payment>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ClientStatus_Response {
fn default() -> &'a SiteServerUI_ClientStatus_Response {
<SiteServerUI_ClientStatus_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ClientStatus_Response {
pub fn new() -> SiteServerUI_ClientStatus_Response {
::std::default::Default::default()
}
pub fn get_clients(&self) -> &[SiteServerUI_ClientStatus_Response_ClientInfo] {
&self.clients
}
pub fn clear_clients(&mut self) {
self.clients.clear();
}
pub fn set_clients(&mut self, v: ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_ClientInfo>) {
self.clients = v;
}
pub fn mut_clients(&mut self) -> &mut ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_ClientInfo> {
&mut self.clients
}
pub fn take_clients(&mut self) -> ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_ClientInfo> {
::std::mem::replace(&mut self.clients, ::protobuf::RepeatedField::new())
}
pub fn get_payments(&self) -> &[SiteServerUI_ClientStatus_Response_Payment] {
&self.payments
}
pub fn clear_payments(&mut self) {
self.payments.clear();
}
pub fn set_payments(&mut self, v: ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_Payment>) {
self.payments = v;
}
pub fn mut_payments(&mut self) -> &mut ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_Payment> {
&mut self.payments
}
pub fn take_payments(&mut self) -> ::protobuf::RepeatedField<SiteServerUI_ClientStatus_Response_Payment> {
::std::mem::replace(&mut self.payments, ::protobuf::RepeatedField::new())
}
}
impl ::protobuf::Message for SiteServerUI_ClientStatus_Response {
fn is_initialized(&self) -> bool {
for v in &self.clients {
if !v.is_initialized() {
return false;
}
};
for v in &self.payments {
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 {
4 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.clients)?;
},
5 => {
::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.payments)?;
},
_ => {
::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.clients {
let len = value.compute_size();
my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len;
};
for value in &self.payments {
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<()> {
for v in &self.clients {
os.write_tag(4, ::protobuf::wire_format::WireTypeLengthDelimited)?;
os.write_raw_varint32(v.get_cached_size())?;
v.write_to_with_cached_sizes(os)?;
};
for v in &self.payments {
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() -> SiteServerUI_ClientStatus_Response {
SiteServerUI_ClientStatus_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::ProtobufTypeMessage<SiteServerUI_ClientStatus_Response_ClientInfo>>(
"clients",
|m: &SiteServerUI_ClientStatus_Response| { &m.clients },
|m: &mut SiteServerUI_ClientStatus_Response| { &mut m.clients },
));
fields.push(::protobuf::reflect::accessor::make_repeated_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage<SiteServerUI_ClientStatus_Response_Payment>>(
"payments",
|m: &SiteServerUI_ClientStatus_Response| { &m.payments },
|m: &mut SiteServerUI_ClientStatus_Response| { &mut m.payments },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_ClientStatus_Response>(
"SiteServerUI_ClientStatus_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ClientStatus_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ClientStatus_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ClientStatus_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ClientStatus_Response {
fn clear(&mut self) {
self.clients.clear();
self.payments.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ClientStatus_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ClientStatus_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ClientStatus_Response_ClientInfo {
ip: ::std::option::Option<u32>,
hostname: ::protobuf::SingularField<::std::string::String>,
connected: ::std::option::Option<bool>,
instance_id: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ClientStatus_Response_ClientInfo {
fn default() -> &'a SiteServerUI_ClientStatus_Response_ClientInfo {
<SiteServerUI_ClientStatus_Response_ClientInfo as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ClientStatus_Response_ClientInfo {
pub fn new() -> SiteServerUI_ClientStatus_Response_ClientInfo {
::std::default::Default::default()
}
pub fn get_ip(&self) -> u32 {
self.ip.unwrap_or(0)
}
pub fn clear_ip(&mut self) {
self.ip = ::std::option::Option::None;
}
pub fn has_ip(&self) -> bool {
self.ip.is_some()
}
pub fn set_ip(&mut self, v: u32) {
self.ip = ::std::option::Option::Some(v);
}
pub fn get_hostname(&self) -> &str {
match self.hostname.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_hostname(&mut self) {
self.hostname.clear();
}
pub fn has_hostname(&self) -> bool {
self.hostname.is_some()
}
pub fn set_hostname(&mut self, v: ::std::string::String) {
self.hostname = ::protobuf::SingularField::some(v);
}
pub fn mut_hostname(&mut self) -> &mut ::std::string::String {
if self.hostname.is_none() {
self.hostname.set_default();
}
self.hostname.as_mut().unwrap()
}
pub fn take_hostname(&mut self) -> ::std::string::String {
self.hostname.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_connected(&self) -> bool {
self.connected.unwrap_or(false)
}
pub fn clear_connected(&mut self) {
self.connected = ::std::option::Option::None;
}
pub fn has_connected(&self) -> bool {
self.connected.is_some()
}
pub fn set_connected(&mut self, v: bool) {
self.connected = ::std::option::Option::Some(v);
}
pub fn get_instance_id(&self) -> u64 {
self.instance_id.unwrap_or(0)
}
pub fn clear_instance_id(&mut self) {
self.instance_id = ::std::option::Option::None;
}
pub fn has_instance_id(&self) -> bool {
self.instance_id.is_some()
}
pub fn set_instance_id(&mut self, v: u64) {
self.instance_id = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_ClientStatus_Response_ClientInfo {
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.ip = ::std::option::Option::Some(tmp);
},
2 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.hostname)?;
},
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.connected = ::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_uint64()?;
self.instance_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.ip {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.hostname.as_ref() {
my_size += ::protobuf::rt::string_size(2, &v);
}
if let Some(v) = self.connected {
my_size += 2;
}
if let Some(v) = self.instance_id {
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.ip {
os.write_uint32(1, v)?;
}
if let Some(ref v) = self.hostname.as_ref() {
os.write_string(2, &v)?;
}
if let Some(v) = self.connected {
os.write_bool(3, v)?;
}
if let Some(v) = self.instance_id {
os.write_uint64(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() -> SiteServerUI_ClientStatus_Response_ClientInfo {
SiteServerUI_ClientStatus_Response_ClientInfo::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>(
"ip",
|m: &SiteServerUI_ClientStatus_Response_ClientInfo| { &m.ip },
|m: &mut SiteServerUI_ClientStatus_Response_ClientInfo| { &mut m.ip },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"hostname",
|m: &SiteServerUI_ClientStatus_Response_ClientInfo| { &m.hostname },
|m: &mut SiteServerUI_ClientStatus_Response_ClientInfo| { &mut m.hostname },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"connected",
|m: &SiteServerUI_ClientStatus_Response_ClientInfo| { &m.connected },
|m: &mut SiteServerUI_ClientStatus_Response_ClientInfo| { &mut m.connected },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"instance_id",
|m: &SiteServerUI_ClientStatus_Response_ClientInfo| { &m.instance_id },
|m: &mut SiteServerUI_ClientStatus_Response_ClientInfo| { &mut m.instance_id },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_ClientStatus_Response_ClientInfo>(
"SiteServerUI_ClientStatus_Response.ClientInfo",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ClientStatus_Response_ClientInfo {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ClientStatus_Response_ClientInfo> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ClientStatus_Response_ClientInfo::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ClientStatus_Response_ClientInfo {
fn clear(&mut self) {
self.ip = ::std::option::Option::None;
self.hostname.clear();
self.connected = ::std::option::Option::None;
self.instance_id = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ClientStatus_Response_ClientInfo {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ClientStatus_Response_ClientInfo {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ClientStatus_Response_Payment {
transid: ::std::option::Option<u64>,
steamid: ::std::option::Option<u64>,
amount: ::protobuf::SingularField<::std::string::String>,
time_created: ::std::option::Option<i32>,
purchase_status: ::std::option::Option<i32>,
hostname: ::protobuf::SingularField<::std::string::String>,
persona_name: ::protobuf::SingularField<::std::string::String>,
profile_url: ::protobuf::SingularField<::std::string::String>,
avatar_url: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ClientStatus_Response_Payment {
fn default() -> &'a SiteServerUI_ClientStatus_Response_Payment {
<SiteServerUI_ClientStatus_Response_Payment as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ClientStatus_Response_Payment {
pub fn new() -> SiteServerUI_ClientStatus_Response_Payment {
::std::default::Default::default()
}
pub fn get_transid(&self) -> u64 {
self.transid.unwrap_or(0)
}
pub fn clear_transid(&mut self) {
self.transid = ::std::option::Option::None;
}
pub fn has_transid(&self) -> bool {
self.transid.is_some()
}
pub fn set_transid(&mut self, v: u64) {
self.transid = ::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_amount(&self) -> &str {
match self.amount.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_amount(&mut self) {
self.amount.clear();
}
pub fn has_amount(&self) -> bool {
self.amount.is_some()
}
pub fn set_amount(&mut self, v: ::std::string::String) {
self.amount = ::protobuf::SingularField::some(v);
}
pub fn mut_amount(&mut self) -> &mut ::std::string::String {
if self.amount.is_none() {
self.amount.set_default();
}
self.amount.as_mut().unwrap()
}
pub fn take_amount(&mut self) -> ::std::string::String {
self.amount.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_time_created(&self) -> i32 {
self.time_created.unwrap_or(0)
}
pub fn clear_time_created(&mut self) {
self.time_created = ::std::option::Option::None;
}
pub fn has_time_created(&self) -> bool {
self.time_created.is_some()
}
pub fn set_time_created(&mut self, v: i32) {
self.time_created = ::std::option::Option::Some(v);
}
pub fn get_purchase_status(&self) -> i32 {
self.purchase_status.unwrap_or(0)
}
pub fn clear_purchase_status(&mut self) {
self.purchase_status = ::std::option::Option::None;
}
pub fn has_purchase_status(&self) -> bool {
self.purchase_status.is_some()
}
pub fn set_purchase_status(&mut self, v: i32) {
self.purchase_status = ::std::option::Option::Some(v);
}
pub fn get_hostname(&self) -> &str {
match self.hostname.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_hostname(&mut self) {
self.hostname.clear();
}
pub fn has_hostname(&self) -> bool {
self.hostname.is_some()
}
pub fn set_hostname(&mut self, v: ::std::string::String) {
self.hostname = ::protobuf::SingularField::some(v);
}
pub fn mut_hostname(&mut self) -> &mut ::std::string::String {
if self.hostname.is_none() {
self.hostname.set_default();
}
self.hostname.as_mut().unwrap()
}
pub fn take_hostname(&mut self) -> ::std::string::String {
self.hostname.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_persona_name(&self) -> &str {
match self.persona_name.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_persona_name(&mut self) {
self.persona_name.clear();
}
pub fn has_persona_name(&self) -> bool {
self.persona_name.is_some()
}
pub fn set_persona_name(&mut self, v: ::std::string::String) {
self.persona_name = ::protobuf::SingularField::some(v);
}
pub fn mut_persona_name(&mut self) -> &mut ::std::string::String {
if self.persona_name.is_none() {
self.persona_name.set_default();
}
self.persona_name.as_mut().unwrap()
}
pub fn take_persona_name(&mut self) -> ::std::string::String {
self.persona_name.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_profile_url(&self) -> &str {
match self.profile_url.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_profile_url(&mut self) {
self.profile_url.clear();
}
pub fn has_profile_url(&self) -> bool {
self.profile_url.is_some()
}
pub fn set_profile_url(&mut self, v: ::std::string::String) {
self.profile_url = ::protobuf::SingularField::some(v);
}
pub fn mut_profile_url(&mut self) -> &mut ::std::string::String {
if self.profile_url.is_none() {
self.profile_url.set_default();
}
self.profile_url.as_mut().unwrap()
}
pub fn take_profile_url(&mut self) -> ::std::string::String {
self.profile_url.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_avatar_url(&self) -> &str {
match self.avatar_url.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_avatar_url(&mut self) {
self.avatar_url.clear();
}
pub fn has_avatar_url(&self) -> bool {
self.avatar_url.is_some()
}
pub fn set_avatar_url(&mut self, v: ::std::string::String) {
self.avatar_url = ::protobuf::SingularField::some(v);
}
pub fn mut_avatar_url(&mut self) -> &mut ::std::string::String {
if self.avatar_url.is_none() {
self.avatar_url.set_default();
}
self.avatar_url.as_mut().unwrap()
}
pub fn take_avatar_url(&mut self) -> ::std::string::String {
self.avatar_url.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for SiteServerUI_ClientStatus_Response_Payment {
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_uint64()?;
self.transid = ::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_uint64()?;
self.steamid = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.amount)?;
},
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.time_created = ::std::option::Option::Some(tmp);
},
5 => {
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.purchase_status = ::std::option::Option::Some(tmp);
},
6 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.hostname)?;
},
7 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.persona_name)?;
},
8 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.profile_url)?;
},
9 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.avatar_url)?;
},
_ => {
::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.transid {
my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.steamid {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.amount.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.time_created {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.purchase_status {
my_size += ::protobuf::rt::value_size(5, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.hostname.as_ref() {
my_size += ::protobuf::rt::string_size(6, &v);
}
if let Some(ref v) = self.persona_name.as_ref() {
my_size += ::protobuf::rt::string_size(7, &v);
}
if let Some(ref v) = self.profile_url.as_ref() {
my_size += ::protobuf::rt::string_size(8, &v);
}
if let Some(ref v) = self.avatar_url.as_ref() {
my_size += ::protobuf::rt::string_size(9, &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.transid {
os.write_uint64(1, v)?;
}
if let Some(v) = self.steamid {
os.write_uint64(2, v)?;
}
if let Some(ref v) = self.amount.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.time_created {
os.write_int32(4, v)?;
}
if let Some(v) = self.purchase_status {
os.write_int32(5, v)?;
}
if let Some(ref v) = self.hostname.as_ref() {
os.write_string(6, &v)?;
}
if let Some(ref v) = self.persona_name.as_ref() {
os.write_string(7, &v)?;
}
if let Some(ref v) = self.profile_url.as_ref() {
os.write_string(8, &v)?;
}
if let Some(ref v) = self.avatar_url.as_ref() {
os.write_string(9, &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() -> SiteServerUI_ClientStatus_Response_Payment {
SiteServerUI_ClientStatus_Response_Payment::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::ProtobufTypeUint64>(
"transid",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.transid },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.transid },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"steamid",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.steamid },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.steamid },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"amount",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.amount },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.amount },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"time_created",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.time_created },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.time_created },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeInt32>(
"purchase_status",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.purchase_status },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.purchase_status },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"hostname",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.hostname },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.hostname },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"persona_name",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.persona_name },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.persona_name },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"profile_url",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.profile_url },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.profile_url },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"avatar_url",
|m: &SiteServerUI_ClientStatus_Response_Payment| { &m.avatar_url },
|m: &mut SiteServerUI_ClientStatus_Response_Payment| { &mut m.avatar_url },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_ClientStatus_Response_Payment>(
"SiteServerUI_ClientStatus_Response.Payment",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ClientStatus_Response_Payment {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ClientStatus_Response_Payment> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ClientStatus_Response_Payment::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ClientStatus_Response_Payment {
fn clear(&mut self) {
self.transid = ::std::option::Option::None;
self.steamid = ::std::option::Option::None;
self.amount.clear();
self.time_created = ::std::option::Option::None;
self.purchase_status = ::std::option::Option::None;
self.hostname.clear();
self.persona_name.clear();
self.profile_url.clear();
self.avatar_url.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ClientStatus_Response_Payment {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ClientStatus_Response_Payment {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ContentCacheStatus_Request {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheStatus_Request {
fn default() -> &'a SiteServerUI_ContentCacheStatus_Request {
<SiteServerUI_ContentCacheStatus_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ContentCacheStatus_Request {
pub fn new() -> SiteServerUI_ContentCacheStatus_Request {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_ContentCacheStatus_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() -> SiteServerUI_ContentCacheStatus_Request {
SiteServerUI_ContentCacheStatus_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::<SiteServerUI_ContentCacheStatus_Request>(
"SiteServerUI_ContentCacheStatus_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ContentCacheStatus_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ContentCacheStatus_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ContentCacheStatus_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ContentCacheStatus_Request {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ContentCacheStatus_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ContentCacheStatus_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ContentCacheStatus_Response {
enabled: ::std::option::Option<bool>,
port: ::std::option::Option<u32>,
cache_location: ::protobuf::SingularField<::std::string::String>,
max_size_gb: ::std::option::Option<u32>,
p2p_enabled: ::std::option::Option<bool>,
explicit_ip_address: ::protobuf::SingularField<::std::string::String>,
external_process: ::std::option::Option<bool>,
current_size_gb: ::std::option::Option<u32>,
current_bw: ::std::option::Option<u64>,
total_bytes_served: ::std::option::Option<u64>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheStatus_Response {
fn default() -> &'a SiteServerUI_ContentCacheStatus_Response {
<SiteServerUI_ContentCacheStatus_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ContentCacheStatus_Response {
pub fn new() -> SiteServerUI_ContentCacheStatus_Response {
::std::default::Default::default()
}
pub fn get_enabled(&self) -> bool {
self.enabled.unwrap_or(false)
}
pub fn clear_enabled(&mut self) {
self.enabled = ::std::option::Option::None;
}
pub fn has_enabled(&self) -> bool {
self.enabled.is_some()
}
pub fn set_enabled(&mut self, v: bool) {
self.enabled = ::std::option::Option::Some(v);
}
pub fn get_port(&self) -> u32 {
self.port.unwrap_or(0)
}
pub fn clear_port(&mut self) {
self.port = ::std::option::Option::None;
}
pub fn has_port(&self) -> bool {
self.port.is_some()
}
pub fn set_port(&mut self, v: u32) {
self.port = ::std::option::Option::Some(v);
}
pub fn get_cache_location(&self) -> &str {
match self.cache_location.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_cache_location(&mut self) {
self.cache_location.clear();
}
pub fn has_cache_location(&self) -> bool {
self.cache_location.is_some()
}
pub fn set_cache_location(&mut self, v: ::std::string::String) {
self.cache_location = ::protobuf::SingularField::some(v);
}
pub fn mut_cache_location(&mut self) -> &mut ::std::string::String {
if self.cache_location.is_none() {
self.cache_location.set_default();
}
self.cache_location.as_mut().unwrap()
}
pub fn take_cache_location(&mut self) -> ::std::string::String {
self.cache_location.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_max_size_gb(&self) -> u32 {
self.max_size_gb.unwrap_or(0)
}
pub fn clear_max_size_gb(&mut self) {
self.max_size_gb = ::std::option::Option::None;
}
pub fn has_max_size_gb(&self) -> bool {
self.max_size_gb.is_some()
}
pub fn set_max_size_gb(&mut self, v: u32) {
self.max_size_gb = ::std::option::Option::Some(v);
}
pub fn get_p2p_enabled(&self) -> bool {
self.p2p_enabled.unwrap_or(false)
}
pub fn clear_p2p_enabled(&mut self) {
self.p2p_enabled = ::std::option::Option::None;
}
pub fn has_p2p_enabled(&self) -> bool {
self.p2p_enabled.is_some()
}
pub fn set_p2p_enabled(&mut self, v: bool) {
self.p2p_enabled = ::std::option::Option::Some(v);
}
pub fn get_explicit_ip_address(&self) -> &str {
match self.explicit_ip_address.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_explicit_ip_address(&mut self) {
self.explicit_ip_address.clear();
}
pub fn has_explicit_ip_address(&self) -> bool {
self.explicit_ip_address.is_some()
}
pub fn set_explicit_ip_address(&mut self, v: ::std::string::String) {
self.explicit_ip_address = ::protobuf::SingularField::some(v);
}
pub fn mut_explicit_ip_address(&mut self) -> &mut ::std::string::String {
if self.explicit_ip_address.is_none() {
self.explicit_ip_address.set_default();
}
self.explicit_ip_address.as_mut().unwrap()
}
pub fn take_explicit_ip_address(&mut self) -> ::std::string::String {
self.explicit_ip_address.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_external_process(&self) -> bool {
self.external_process.unwrap_or(false)
}
pub fn clear_external_process(&mut self) {
self.external_process = ::std::option::Option::None;
}
pub fn has_external_process(&self) -> bool {
self.external_process.is_some()
}
pub fn set_external_process(&mut self, v: bool) {
self.external_process = ::std::option::Option::Some(v);
}
pub fn get_current_size_gb(&self) -> u32 {
self.current_size_gb.unwrap_or(0)
}
pub fn clear_current_size_gb(&mut self) {
self.current_size_gb = ::std::option::Option::None;
}
pub fn has_current_size_gb(&self) -> bool {
self.current_size_gb.is_some()
}
pub fn set_current_size_gb(&mut self, v: u32) {
self.current_size_gb = ::std::option::Option::Some(v);
}
pub fn get_current_bw(&self) -> u64 {
self.current_bw.unwrap_or(0)
}
pub fn clear_current_bw(&mut self) {
self.current_bw = ::std::option::Option::None;
}
pub fn has_current_bw(&self) -> bool {
self.current_bw.is_some()
}
pub fn set_current_bw(&mut self, v: u64) {
self.current_bw = ::std::option::Option::Some(v);
}
pub fn get_total_bytes_served(&self) -> u64 {
self.total_bytes_served.unwrap_or(0)
}
pub fn clear_total_bytes_served(&mut self) {
self.total_bytes_served = ::std::option::Option::None;
}
pub fn has_total_bytes_served(&self) -> bool {
self.total_bytes_served.is_some()
}
pub fn set_total_bytes_served(&mut self, v: u64) {
self.total_bytes_served = ::std::option::Option::Some(v);
}
}
impl ::protobuf::Message for SiteServerUI_ContentCacheStatus_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_bool()?;
self.enabled = ::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.port = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cache_location)?;
},
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.max_size_gb = ::std::option::Option::Some(tmp);
},
5 => {
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.p2p_enabled = ::std::option::Option::Some(tmp);
},
9 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.explicit_ip_address)?;
},
10 => {
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.external_process = ::std::option::Option::Some(tmp);
},
6 => {
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.current_size_gb = ::std::option::Option::Some(tmp);
},
7 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.current_bw = ::std::option::Option::Some(tmp);
},
8 => {
if wire_type != ::protobuf::wire_format::WireTypeVarint {
return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type));
}
let tmp = is.read_uint64()?;
self.total_bytes_served = ::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.enabled {
my_size += 2;
}
if let Some(v) = self.port {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.cache_location.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.max_size_gb {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.p2p_enabled {
my_size += 2;
}
if let Some(ref v) = self.explicit_ip_address.as_ref() {
my_size += ::protobuf::rt::string_size(9, &v);
}
if let Some(v) = self.external_process {
my_size += 2;
}
if let Some(v) = self.current_size_gb {
my_size += ::protobuf::rt::value_size(6, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.current_bw {
my_size += ::protobuf::rt::value_size(7, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.total_bytes_served {
my_size += ::protobuf::rt::value_size(8, 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.enabled {
os.write_bool(1, v)?;
}
if let Some(v) = self.port {
os.write_uint32(2, v)?;
}
if let Some(ref v) = self.cache_location.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.max_size_gb {
os.write_uint32(4, v)?;
}
if let Some(v) = self.p2p_enabled {
os.write_bool(5, v)?;
}
if let Some(ref v) = self.explicit_ip_address.as_ref() {
os.write_string(9, &v)?;
}
if let Some(v) = self.external_process {
os.write_bool(10, v)?;
}
if let Some(v) = self.current_size_gb {
os.write_uint32(6, v)?;
}
if let Some(v) = self.current_bw {
os.write_uint64(7, v)?;
}
if let Some(v) = self.total_bytes_served {
os.write_uint64(8, 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() -> SiteServerUI_ContentCacheStatus_Response {
SiteServerUI_ContentCacheStatus_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::ProtobufTypeBool>(
"enabled",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.enabled },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.enabled },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"port",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.port },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.port },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"cache_location",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.cache_location },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.cache_location },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"max_size_gb",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.max_size_gb },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.max_size_gb },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"p2p_enabled",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.p2p_enabled },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.p2p_enabled },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"explicit_ip_address",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.explicit_ip_address },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.explicit_ip_address },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"external_process",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.external_process },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.external_process },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"current_size_gb",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.current_size_gb },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.current_size_gb },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"current_bw",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.current_bw },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.current_bw },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint64>(
"total_bytes_served",
|m: &SiteServerUI_ContentCacheStatus_Response| { &m.total_bytes_served },
|m: &mut SiteServerUI_ContentCacheStatus_Response| { &mut m.total_bytes_served },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_ContentCacheStatus_Response>(
"SiteServerUI_ContentCacheStatus_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ContentCacheStatus_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ContentCacheStatus_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ContentCacheStatus_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ContentCacheStatus_Response {
fn clear(&mut self) {
self.enabled = ::std::option::Option::None;
self.port = ::std::option::Option::None;
self.cache_location.clear();
self.max_size_gb = ::std::option::Option::None;
self.p2p_enabled = ::std::option::Option::None;
self.explicit_ip_address.clear();
self.external_process = ::std::option::Option::None;
self.current_size_gb = ::std::option::Option::None;
self.current_bw = ::std::option::Option::None;
self.total_bytes_served = ::std::option::Option::None;
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ContentCacheStatus_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ContentCacheStatus_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ContentCacheConfig_Request {
enabled: ::std::option::Option<bool>,
port: ::std::option::Option<u32>,
cache_location: ::protobuf::SingularField<::std::string::String>,
max_size_gb: ::std::option::Option<u32>,
p2p_enabled: ::std::option::Option<bool>,
external_process: ::std::option::Option<bool>,
explicit_ip_address: ::protobuf::SingularField<::std::string::String>,
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheConfig_Request {
fn default() -> &'a SiteServerUI_ContentCacheConfig_Request {
<SiteServerUI_ContentCacheConfig_Request as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ContentCacheConfig_Request {
pub fn new() -> SiteServerUI_ContentCacheConfig_Request {
::std::default::Default::default()
}
pub fn get_enabled(&self) -> bool {
self.enabled.unwrap_or(false)
}
pub fn clear_enabled(&mut self) {
self.enabled = ::std::option::Option::None;
}
pub fn has_enabled(&self) -> bool {
self.enabled.is_some()
}
pub fn set_enabled(&mut self, v: bool) {
self.enabled = ::std::option::Option::Some(v);
}
pub fn get_port(&self) -> u32 {
self.port.unwrap_or(0)
}
pub fn clear_port(&mut self) {
self.port = ::std::option::Option::None;
}
pub fn has_port(&self) -> bool {
self.port.is_some()
}
pub fn set_port(&mut self, v: u32) {
self.port = ::std::option::Option::Some(v);
}
pub fn get_cache_location(&self) -> &str {
match self.cache_location.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_cache_location(&mut self) {
self.cache_location.clear();
}
pub fn has_cache_location(&self) -> bool {
self.cache_location.is_some()
}
pub fn set_cache_location(&mut self, v: ::std::string::String) {
self.cache_location = ::protobuf::SingularField::some(v);
}
pub fn mut_cache_location(&mut self) -> &mut ::std::string::String {
if self.cache_location.is_none() {
self.cache_location.set_default();
}
self.cache_location.as_mut().unwrap()
}
pub fn take_cache_location(&mut self) -> ::std::string::String {
self.cache_location.take().unwrap_or_else(|| ::std::string::String::new())
}
pub fn get_max_size_gb(&self) -> u32 {
self.max_size_gb.unwrap_or(0)
}
pub fn clear_max_size_gb(&mut self) {
self.max_size_gb = ::std::option::Option::None;
}
pub fn has_max_size_gb(&self) -> bool {
self.max_size_gb.is_some()
}
pub fn set_max_size_gb(&mut self, v: u32) {
self.max_size_gb = ::std::option::Option::Some(v);
}
pub fn get_p2p_enabled(&self) -> bool {
self.p2p_enabled.unwrap_or(false)
}
pub fn clear_p2p_enabled(&mut self) {
self.p2p_enabled = ::std::option::Option::None;
}
pub fn has_p2p_enabled(&self) -> bool {
self.p2p_enabled.is_some()
}
pub fn set_p2p_enabled(&mut self, v: bool) {
self.p2p_enabled = ::std::option::Option::Some(v);
}
pub fn get_external_process(&self) -> bool {
self.external_process.unwrap_or(false)
}
pub fn clear_external_process(&mut self) {
self.external_process = ::std::option::Option::None;
}
pub fn has_external_process(&self) -> bool {
self.external_process.is_some()
}
pub fn set_external_process(&mut self, v: bool) {
self.external_process = ::std::option::Option::Some(v);
}
pub fn get_explicit_ip_address(&self) -> &str {
match self.explicit_ip_address.as_ref() {
Some(v) => &v,
None => "",
}
}
pub fn clear_explicit_ip_address(&mut self) {
self.explicit_ip_address.clear();
}
pub fn has_explicit_ip_address(&self) -> bool {
self.explicit_ip_address.is_some()
}
pub fn set_explicit_ip_address(&mut self, v: ::std::string::String) {
self.explicit_ip_address = ::protobuf::SingularField::some(v);
}
pub fn mut_explicit_ip_address(&mut self) -> &mut ::std::string::String {
if self.explicit_ip_address.is_none() {
self.explicit_ip_address.set_default();
}
self.explicit_ip_address.as_mut().unwrap()
}
pub fn take_explicit_ip_address(&mut self) -> ::std::string::String {
self.explicit_ip_address.take().unwrap_or_else(|| ::std::string::String::new())
}
}
impl ::protobuf::Message for SiteServerUI_ContentCacheConfig_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_bool()?;
self.enabled = ::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.port = ::std::option::Option::Some(tmp);
},
3 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.cache_location)?;
},
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.max_size_gb = ::std::option::Option::Some(tmp);
},
5 => {
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.p2p_enabled = ::std::option::Option::Some(tmp);
},
6 => {
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.external_process = ::std::option::Option::Some(tmp);
},
7 => {
::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.explicit_ip_address)?;
},
_ => {
::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.enabled {
my_size += 2;
}
if let Some(v) = self.port {
my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(ref v) = self.cache_location.as_ref() {
my_size += ::protobuf::rt::string_size(3, &v);
}
if let Some(v) = self.max_size_gb {
my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint);
}
if let Some(v) = self.p2p_enabled {
my_size += 2;
}
if let Some(v) = self.external_process {
my_size += 2;
}
if let Some(ref v) = self.explicit_ip_address.as_ref() {
my_size += ::protobuf::rt::string_size(7, &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.enabled {
os.write_bool(1, v)?;
}
if let Some(v) = self.port {
os.write_uint32(2, v)?;
}
if let Some(ref v) = self.cache_location.as_ref() {
os.write_string(3, &v)?;
}
if let Some(v) = self.max_size_gb {
os.write_uint32(4, v)?;
}
if let Some(v) = self.p2p_enabled {
os.write_bool(5, v)?;
}
if let Some(v) = self.external_process {
os.write_bool(6, v)?;
}
if let Some(ref v) = self.explicit_ip_address.as_ref() {
os.write_string(7, &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() -> SiteServerUI_ContentCacheConfig_Request {
SiteServerUI_ContentCacheConfig_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::ProtobufTypeBool>(
"enabled",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.enabled },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.enabled },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"port",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.port },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.port },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"cache_location",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.cache_location },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.cache_location },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>(
"max_size_gb",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.max_size_gb },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.max_size_gb },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"p2p_enabled",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.p2p_enabled },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.p2p_enabled },
));
fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>(
"external_process",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.external_process },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.external_process },
));
fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"explicit_ip_address",
|m: &SiteServerUI_ContentCacheConfig_Request| { &m.explicit_ip_address },
|m: &mut SiteServerUI_ContentCacheConfig_Request| { &mut m.explicit_ip_address },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<SiteServerUI_ContentCacheConfig_Request>(
"SiteServerUI_ContentCacheConfig_Request",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ContentCacheConfig_Request {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ContentCacheConfig_Request> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ContentCacheConfig_Request::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ContentCacheConfig_Request {
fn clear(&mut self) {
self.enabled = ::std::option::Option::None;
self.port = ::std::option::Option::None;
self.cache_location.clear();
self.max_size_gb = ::std::option::Option::None;
self.p2p_enabled = ::std::option::Option::None;
self.external_process = ::std::option::Option::None;
self.explicit_ip_address.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ContentCacheConfig_Request {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ContentCacheConfig_Request {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
#[derive(PartialEq,Clone,Default)]
pub struct SiteServerUI_ContentCacheConfig_Response {
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a SiteServerUI_ContentCacheConfig_Response {
fn default() -> &'a SiteServerUI_ContentCacheConfig_Response {
<SiteServerUI_ContentCacheConfig_Response as ::protobuf::Message>::default_instance()
}
}
impl SiteServerUI_ContentCacheConfig_Response {
pub fn new() -> SiteServerUI_ContentCacheConfig_Response {
::std::default::Default::default()
}
}
impl ::protobuf::Message for SiteServerUI_ContentCacheConfig_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() -> SiteServerUI_ContentCacheConfig_Response {
SiteServerUI_ContentCacheConfig_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::<SiteServerUI_ContentCacheConfig_Response>(
"SiteServerUI_ContentCacheConfig_Response",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static SiteServerUI_ContentCacheConfig_Response {
static instance: ::protobuf::rt::LazyV2<SiteServerUI_ContentCacheConfig_Response> = ::protobuf::rt::LazyV2::INIT;
instance.get(SiteServerUI_ContentCacheConfig_Response::new)
}
}
impl ::protobuf::Clear for SiteServerUI_ContentCacheConfig_Response {
fn clear(&mut self) {
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for SiteServerUI_ContentCacheConfig_Response {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for SiteServerUI_ContentCacheConfig_Response {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x20steammessages_siteserverui.proto\x1a\x18steammessages_base.proto\"\
\xa9\x01\n\x1aSiteServerUI_Login_Request\x12\x1a\n\x08username\x18\x01\
\x20\x01(\tR\x08username\x12\x1a\n\x08password\x18\x02\x20\x01(\tR\x08pa\
ssword\x12&\n\x0esteamguardcode\x18\x03\x20\x01(\tR\x0esteamguardcode\
\x12+\n\x11remember_password\x18\x04\x20\x01(\x08R\x10rememberPassword\"\
c\n\x1bSiteServerUI_Login_Response\x12\x1f\n\x0blogon_state\x18\x01\x20\
\x01(\x05R\nlogonState\x12#\n\rlogon_eresult\x18\x02\x20\x01(\x05R\x0clo\
gonEresult\"\"\n\x20SiteServerUI_LoginStatus_Request\"\xb4\x01\n!SiteSer\
verUI_LoginStatus_Response\x12\x1a\n\x08username\x18\x01\x20\x01(\tR\x08\
username\x12-\n\x12cached_credentials\x18\x02\x20\x01(\x08R\x11cachedCre\
dentials\x12\x1f\n\x0blogon_state\x18\x03\x20\x01(\x05R\nlogonState\x12#\
\n\rlogon_eresult\x18\x04\x20\x01(\x05R\x0clogonEresult\"\"\n\x20SiteSer\
verUI_CancelLogin_Request\"i\n!SiteServerUI_CancelLogin_Response\x12\x1f\
\n\x0blogon_state\x18\x01\x20\x01(\x05R\nlogonState\x12#\n\rlogon_eresul\
t\x18\x02\x20\x01(\x05R\x0clogonEresult\"\x1d\n\x1bSiteServerUI_Logout_R\
equest\"f\n\x1cSiteServerUI_Logout_Response\x12\x1f\n\x0blogon_state\x18\
\x01\x20\x01(\x05R\nlogonState\x12%\n\x0elogout_eresult\x18\x02\x20\x01(\
\x05R\rlogoutEresult\"5\n\x19SiteServerUI_Quit_Request\x12\x18\n\x07rest\
art\x18\x01\x20\x01(\x08R\x07restart\"\x1c\n\x1aSiteServerUI_Quit_Respon\
se\"\x1d\n\x1bSiteServerUI_Status_Request\"\xc8\x01\n\x1cSiteServerUI_St\
atus_Response\x12\x1f\n\x0blogon_state\x18\x01\x20\x01(\x05R\nlogonState\
\x12#\n\rlogon_eresult\x18\x02\x20\x01(\x05R\x0clogonEresult\x12\x1c\n\t\
connected\x18\x03\x20\x01(\x08R\tconnected\x12#\n\rcache_enabled\x18\x04\
\x20\x01(\x08R\x0ccacheEnabled\x12\x1f\n\x0bacct_status\x18\x05\x20\x01(\
\x05R\nacctStatus\"\"\n\x20SiteServerUI_GetLanguage_Request\"?\n!SiteSer\
verUI_GetLanguage_Response\x12\x1a\n\x08language\x18\x01\x20\x01(\tR\x08\
language\">\n\x20SiteServerUI_SetLanguage_Request\x12\x1a\n\x08language\
\x18\x01\x20\x01(\tR\x08language\"#\n!SiteServerUI_SetLanguage_Response\
\"#\n!SiteServerUI_ClientStatus_Request\"\xd3\x04\n\"SiteServerUI_Client\
Status_Response\x12H\n\x07clients\x18\x04\x20\x03(\x0b2..SiteServerUI_Cl\
ientStatus_Response.ClientInfoR\x07clients\x12G\n\x08payments\x18\x05\
\x20\x03(\x0b2+.SiteServerUI_ClientStatus_Response.PaymentR\x08payments\
\x1aw\n\nClientInfo\x12\x0e\n\x02ip\x18\x01\x20\x01(\rR\x02ip\x12\x1a\n\
\x08hostname\x18\x02\x20\x01(\tR\x08hostname\x12\x1c\n\tconnected\x18\
\x03\x20\x01(\x08R\tconnected\x12\x1f\n\x0binstance_id\x18\x04\x20\x01(\
\x04R\ninstanceId\x1a\xa0\x02\n\x07Payment\x12\x18\n\x07transid\x18\x01\
\x20\x01(\x04R\x07transid\x12\x18\n\x07steamid\x18\x02\x20\x01(\x04R\x07\
steamid\x12\x16\n\x06amount\x18\x03\x20\x01(\tR\x06amount\x12!\n\x0ctime\
_created\x18\x04\x20\x01(\x05R\x0btimeCreated\x12'\n\x0fpurchase_status\
\x18\x05\x20\x01(\x05R\x0epurchaseStatus\x12\x1a\n\x08hostname\x18\x06\
\x20\x01(\tR\x08hostname\x12!\n\x0cpersona_name\x18\x07\x20\x01(\tR\x0bp\
ersonaName\x12\x1f\n\x0bprofile_url\x18\x08\x20\x01(\tR\nprofileUrl\x12\
\x1d\n\navatar_url\x18\t\x20\x01(\tR\tavatarUrl\")\n'SiteServerUI_Conten\
tCacheStatus_Request\"\x90\x03\n(SiteServerUI_ContentCacheStatus_Respons\
e\x12\x18\n\x07enabled\x18\x01\x20\x01(\x08R\x07enabled\x12\x12\n\x04por\
t\x18\x02\x20\x01(\rR\x04port\x12%\n\x0ecache_location\x18\x03\x20\x01(\
\tR\rcacheLocation\x12\x1e\n\x0bmax_size_gb\x18\x04\x20\x01(\rR\tmaxSize\
Gb\x12\x1f\n\x0bp2p_enabled\x18\x05\x20\x01(\x08R\np2pEnabled\x12.\n\x13\
explicit_ip_address\x18\t\x20\x01(\tR\x11explicitIpAddress\x12)\n\x10ext\
ernal_process\x18\n\x20\x01(\x08R\x0fexternalProcess\x12&\n\x0fcurrent_s\
ize_gb\x18\x06\x20\x01(\rR\rcurrentSizeGb\x12\x1d\n\ncurrent_bw\x18\x07\
\x20\x01(\x04R\tcurrentBw\x12,\n\x12total_bytes_served\x18\x08\x20\x01(\
\x04R\x10totalBytesServed\"\x9a\x02\n'SiteServerUI_ContentCacheConfig_Re\
quest\x12\x18\n\x07enabled\x18\x01\x20\x01(\x08R\x07enabled\x12\x12\n\
\x04port\x18\x02\x20\x01(\rR\x04port\x12%\n\x0ecache_location\x18\x03\
\x20\x01(\tR\rcacheLocation\x12\x1e\n\x0bmax_size_gb\x18\x04\x20\x01(\rR\
\tmaxSizeGb\x12\x1f\n\x0bp2p_enabled\x18\x05\x20\x01(\x08R\np2pEnabled\
\x12)\n\x10external_process\x18\x06\x20\x01(\x08R\x0fexternalProcess\x12\
.\n\x13explicit_ip_address\x18\x07\x20\x01(\tR\x11explicitIpAddress\"*\n\
(SiteServerUI_ContentCacheConfig_ResponseB\x05H\x01\x80\x01\0J\x99#\n\
\x07\x12\x05\0\0\x81\x01\x01\n\t\n\x02\x03\0\x12\x03\0\0\"\n\x08\n\x01\
\x08\x12\x03\x02\0\x1c\n\t\n\x02\x08\t\x12\x03\x02\0\x1c\n\x08\n\x01\x08\
\x12\x03\x03\0#\n\t\n\x02\x08\x10\x12\x03\x03\0#\n\n\n\x02\x04\0\x12\x04\
\x05\0\n\x01\n\n\n\x03\x04\0\x01\x12\x03\x05\x08\"\n\x0b\n\x04\x04\0\x02\
\0\x12\x03\x06\x08%\n\x0c\n\x05\x04\0\x02\0\x04\x12\x03\x06\x08\x10\n\
\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x06\x11\x17\n\x0c\n\x05\x04\0\x02\0\
\x01\x12\x03\x06\x18\x20\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x06#$\n\x0b\
\n\x04\x04\0\x02\x01\x12\x03\x07\x08%\n\x0c\n\x05\x04\0\x02\x01\x04\x12\
\x03\x07\x08\x10\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x07\x11\x17\n\x0c\
\n\x05\x04\0\x02\x01\x01\x12\x03\x07\x18\x20\n\x0c\n\x05\x04\0\x02\x01\
\x03\x12\x03\x07#$\n\x0b\n\x04\x04\0\x02\x02\x12\x03\x08\x08+\n\x0c\n\
\x05\x04\0\x02\x02\x04\x12\x03\x08\x08\x10\n\x0c\n\x05\x04\0\x02\x02\x05\
\x12\x03\x08\x11\x17\n\x0c\n\x05\x04\0\x02\x02\x01\x12\x03\x08\x18&\n\
\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\x08)*\n\x0b\n\x04\x04\0\x02\x03\x12\
\x03\t\x08,\n\x0c\n\x05\x04\0\x02\x03\x04\x12\x03\t\x08\x10\n\x0c\n\x05\
\x04\0\x02\x03\x05\x12\x03\t\x11\x15\n\x0c\n\x05\x04\0\x02\x03\x01\x12\
\x03\t\x16'\n\x0c\n\x05\x04\0\x02\x03\x03\x12\x03\t*+\n\n\n\x02\x04\x01\
\x12\x04\x0c\0\x0f\x01\n\n\n\x03\x04\x01\x01\x12\x03\x0c\x08#\n\x0b\n\
\x04\x04\x01\x02\0\x12\x03\r\x08'\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\
\r\x08\x10\n\x0c\n\x05\x04\x01\x02\0\x05\x12\x03\r\x11\x16\n\x0c\n\x05\
\x04\x01\x02\0\x01\x12\x03\r\x17\"\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\
\r%&\n\x0b\n\x04\x04\x01\x02\x01\x12\x03\x0e\x08)\n\x0c\n\x05\x04\x01\
\x02\x01\x04\x12\x03\x0e\x08\x10\n\x0c\n\x05\x04\x01\x02\x01\x05\x12\x03\
\x0e\x11\x16\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x0e\x17$\n\x0c\n\
\x05\x04\x01\x02\x01\x03\x12\x03\x0e'(\n\n\n\x02\x04\x02\x12\x04\x11\0\
\x12\x01\n\n\n\x03\x04\x02\x01\x12\x03\x11\x08(\n\n\n\x02\x04\x03\x12\
\x04\x14\0\x19\x01\n\n\n\x03\x04\x03\x01\x12\x03\x14\x08)\n\x0b\n\x04\
\x04\x03\x02\0\x12\x03\x15\x08%\n\x0c\n\x05\x04\x03\x02\0\x04\x12\x03\
\x15\x08\x10\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03\x15\x11\x17\n\x0c\n\
\x05\x04\x03\x02\0\x01\x12\x03\x15\x18\x20\n\x0c\n\x05\x04\x03\x02\0\x03\
\x12\x03\x15#$\n\x0b\n\x04\x04\x03\x02\x01\x12\x03\x16\x08-\n\x0c\n\x05\
\x04\x03\x02\x01\x04\x12\x03\x16\x08\x10\n\x0c\n\x05\x04\x03\x02\x01\x05\
\x12\x03\x16\x11\x15\n\x0c\n\x05\x04\x03\x02\x01\x01\x12\x03\x16\x16(\n\
\x0c\n\x05\x04\x03\x02\x01\x03\x12\x03\x16+,\n\x0b\n\x04\x04\x03\x02\x02\
\x12\x03\x17\x08'\n\x0c\n\x05\x04\x03\x02\x02\x04\x12\x03\x17\x08\x10\n\
\x0c\n\x05\x04\x03\x02\x02\x05\x12\x03\x17\x11\x16\n\x0c\n\x05\x04\x03\
\x02\x02\x01\x12\x03\x17\x17\"\n\x0c\n\x05\x04\x03\x02\x02\x03\x12\x03\
\x17%&\n\x0b\n\x04\x04\x03\x02\x03\x12\x03\x18\x08)\n\x0c\n\x05\x04\x03\
\x02\x03\x04\x12\x03\x18\x08\x10\n\x0c\n\x05\x04\x03\x02\x03\x05\x12\x03\
\x18\x11\x16\n\x0c\n\x05\x04\x03\x02\x03\x01\x12\x03\x18\x17$\n\x0c\n\
\x05\x04\x03\x02\x03\x03\x12\x03\x18'(\n\n\n\x02\x04\x04\x12\x04\x1b\0\
\x1c\x01\n\n\n\x03\x04\x04\x01\x12\x03\x1b\x08(\n\n\n\x02\x04\x05\x12\
\x04\x1e\0!\x01\n\n\n\x03\x04\x05\x01\x12\x03\x1e\x08)\n\x0b\n\x04\x04\
\x05\x02\0\x12\x03\x1f\x08'\n\x0c\n\x05\x04\x05\x02\0\x04\x12\x03\x1f\
\x08\x10\n\x0c\n\x05\x04\x05\x02\0\x05\x12\x03\x1f\x11\x16\n\x0c\n\x05\
\x04\x05\x02\0\x01\x12\x03\x1f\x17\"\n\x0c\n\x05\x04\x05\x02\0\x03\x12\
\x03\x1f%&\n\x0b\n\x04\x04\x05\x02\x01\x12\x03\x20\x08)\n\x0c\n\x05\x04\
\x05\x02\x01\x04\x12\x03\x20\x08\x10\n\x0c\n\x05\x04\x05\x02\x01\x05\x12\
\x03\x20\x11\x16\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x03\x20\x17$\n\x0c\
\n\x05\x04\x05\x02\x01\x03\x12\x03\x20'(\n\n\n\x02\x04\x06\x12\x04#\0$\
\x01\n\n\n\x03\x04\x06\x01\x12\x03#\x08#\n\n\n\x02\x04\x07\x12\x04&\0)\
\x01\n\n\n\x03\x04\x07\x01\x12\x03&\x08$\n\x0b\n\x04\x04\x07\x02\0\x12\
\x03'\x08'\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x03'\x08\x10\n\x0c\n\x05\
\x04\x07\x02\0\x05\x12\x03'\x11\x16\n\x0c\n\x05\x04\x07\x02\0\x01\x12\
\x03'\x17\"\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x03'%&\n\x0b\n\x04\x04\x07\
\x02\x01\x12\x03(\x08*\n\x0c\n\x05\x04\x07\x02\x01\x04\x12\x03(\x08\x10\
\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\x03(\x11\x16\n\x0c\n\x05\x04\x07\
\x02\x01\x01\x12\x03(\x17%\n\x0c\n\x05\x04\x07\x02\x01\x03\x12\x03(()\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\x15\n\x0c\n\
\x05\x04\x08\x02\0\x01\x12\x03,\x16\x1d\n\x0c\n\x05\x04\x08\x02\0\x03\
\x12\x03,\x20!\n\n\n\x02\x04\t\x12\x04/\00\x01\n\n\n\x03\x04\t\x01\x12\
\x03/\x08\"\n\n\n\x02\x04\n\x12\x042\03\x01\n\n\n\x03\x04\n\x01\x12\x032\
\x08#\n\n\n\x02\x04\x0b\x12\x045\0;\x01\n\n\n\x03\x04\x0b\x01\x12\x035\
\x08$\n\x0b\n\x04\x04\x0b\x02\0\x12\x036\x08'\n\x0c\n\x05\x04\x0b\x02\0\
\x04\x12\x036\x08\x10\n\x0c\n\x05\x04\x0b\x02\0\x05\x12\x036\x11\x16\n\
\x0c\n\x05\x04\x0b\x02\0\x01\x12\x036\x17\"\n\x0c\n\x05\x04\x0b\x02\0\
\x03\x12\x036%&\n\x0b\n\x04\x04\x0b\x02\x01\x12\x037\x08)\n\x0c\n\x05\
\x04\x0b\x02\x01\x04\x12\x037\x08\x10\n\x0c\n\x05\x04\x0b\x02\x01\x05\
\x12\x037\x11\x16\n\x0c\n\x05\x04\x0b\x02\x01\x01\x12\x037\x17$\n\x0c\n\
\x05\x04\x0b\x02\x01\x03\x12\x037'(\n\x0b\n\x04\x04\x0b\x02\x02\x12\x038\
\x08$\n\x0c\n\x05\x04\x0b\x02\x02\x04\x12\x038\x08\x10\n\x0c\n\x05\x04\
\x0b\x02\x02\x05\x12\x038\x11\x15\n\x0c\n\x05\x04\x0b\x02\x02\x01\x12\
\x038\x16\x1f\n\x0c\n\x05\x04\x0b\x02\x02\x03\x12\x038\"#\n\x0b\n\x04\
\x04\x0b\x02\x03\x12\x039\x08(\n\x0c\n\x05\x04\x0b\x02\x03\x04\x12\x039\
\x08\x10\n\x0c\n\x05\x04\x0b\x02\x03\x05\x12\x039\x11\x15\n\x0c\n\x05\
\x04\x0b\x02\x03\x01\x12\x039\x16#\n\x0c\n\x05\x04\x0b\x02\x03\x03\x12\
\x039&'\n\x0b\n\x04\x04\x0b\x02\x04\x12\x03:\x08'\n\x0c\n\x05\x04\x0b\
\x02\x04\x04\x12\x03:\x08\x10\n\x0c\n\x05\x04\x0b\x02\x04\x05\x12\x03:\
\x11\x16\n\x0c\n\x05\x04\x0b\x02\x04\x01\x12\x03:\x17\"\n\x0c\n\x05\x04\
\x0b\x02\x04\x03\x12\x03:%&\n\n\n\x02\x04\x0c\x12\x04=\0>\x01\n\n\n\x03\
\x04\x0c\x01\x12\x03=\x08(\n\n\n\x02\x04\r\x12\x04@\0B\x01\n\n\n\x03\x04\
\r\x01\x12\x03@\x08)\n\x0b\n\x04\x04\r\x02\0\x12\x03A\x08%\n\x0c\n\x05\
\x04\r\x02\0\x04\x12\x03A\x08\x10\n\x0c\n\x05\x04\r\x02\0\x05\x12\x03A\
\x11\x17\n\x0c\n\x05\x04\r\x02\0\x01\x12\x03A\x18\x20\n\x0c\n\x05\x04\r\
\x02\0\x03\x12\x03A#$\n\n\n\x02\x04\x0e\x12\x04D\0F\x01\n\n\n\x03\x04\
\x0e\x01\x12\x03D\x08(\n\x0b\n\x04\x04\x0e\x02\0\x12\x03E\x08%\n\x0c\n\
\x05\x04\x0e\x02\0\x04\x12\x03E\x08\x10\n\x0c\n\x05\x04\x0e\x02\0\x05\
\x12\x03E\x11\x17\n\x0c\n\x05\x04\x0e\x02\0\x01\x12\x03E\x18\x20\n\x0c\n\
\x05\x04\x0e\x02\0\x03\x12\x03E#$\n\n\n\x02\x04\x0f\x12\x04H\0I\x01\n\n\
\n\x03\x04\x0f\x01\x12\x03H\x08)\n\n\n\x02\x04\x10\x12\x04K\0L\x01\n\n\n\
\x03\x04\x10\x01\x12\x03K\x08)\n\n\n\x02\x04\x11\x12\x04N\0d\x01\n\n\n\
\x03\x04\x11\x01\x12\x03N\x08*\n\x0c\n\x04\x04\x11\x03\0\x12\x04O\x08T\t\
\n\x0c\n\x05\x04\x11\x03\0\x01\x12\x03O\x10\x1a\n\r\n\x06\x04\x11\x03\0\
\x02\0\x12\x03P\x10'\n\x0e\n\x07\x04\x11\x03\0\x02\0\x04\x12\x03P\x10\
\x18\n\x0e\n\x07\x04\x11\x03\0\x02\0\x05\x12\x03P\x19\x1f\n\x0e\n\x07\
\x04\x11\x03\0\x02\0\x01\x12\x03P\x20\"\n\x0e\n\x07\x04\x11\x03\0\x02\0\
\x03\x12\x03P%&\n\r\n\x06\x04\x11\x03\0\x02\x01\x12\x03Q\x10-\n\x0e\n\
\x07\x04\x11\x03\0\x02\x01\x04\x12\x03Q\x10\x18\n\x0e\n\x07\x04\x11\x03\
\0\x02\x01\x05\x12\x03Q\x19\x1f\n\x0e\n\x07\x04\x11\x03\0\x02\x01\x01\
\x12\x03Q\x20(\n\x0e\n\x07\x04\x11\x03\0\x02\x01\x03\x12\x03Q+,\n\r\n\
\x06\x04\x11\x03\0\x02\x02\x12\x03R\x10,\n\x0e\n\x07\x04\x11\x03\0\x02\
\x02\x04\x12\x03R\x10\x18\n\x0e\n\x07\x04\x11\x03\0\x02\x02\x05\x12\x03R\
\x19\x1d\n\x0e\n\x07\x04\x11\x03\0\x02\x02\x01\x12\x03R\x1e'\n\x0e\n\x07\
\x04\x11\x03\0\x02\x02\x03\x12\x03R*+\n\r\n\x06\x04\x11\x03\0\x02\x03\
\x12\x03S\x100\n\x0e\n\x07\x04\x11\x03\0\x02\x03\x04\x12\x03S\x10\x18\n\
\x0e\n\x07\x04\x11\x03\0\x02\x03\x05\x12\x03S\x19\x1f\n\x0e\n\x07\x04\
\x11\x03\0\x02\x03\x01\x12\x03S\x20+\n\x0e\n\x07\x04\x11\x03\0\x02\x03\
\x03\x12\x03S./\n\x0c\n\x04\x04\x11\x03\x01\x12\x04V\x08`\t\n\x0c\n\x05\
\x04\x11\x03\x01\x01\x12\x03V\x10\x17\n\r\n\x06\x04\x11\x03\x01\x02\0\
\x12\x03W\x10,\n\x0e\n\x07\x04\x11\x03\x01\x02\0\x04\x12\x03W\x10\x18\n\
\x0e\n\x07\x04\x11\x03\x01\x02\0\x05\x12\x03W\x19\x1f\n\x0e\n\x07\x04\
\x11\x03\x01\x02\0\x01\x12\x03W\x20'\n\x0e\n\x07\x04\x11\x03\x01\x02\0\
\x03\x12\x03W*+\n\r\n\x06\x04\x11\x03\x01\x02\x01\x12\x03X\x10,\n\x0e\n\
\x07\x04\x11\x03\x01\x02\x01\x04\x12\x03X\x10\x18\n\x0e\n\x07\x04\x11\
\x03\x01\x02\x01\x05\x12\x03X\x19\x1f\n\x0e\n\x07\x04\x11\x03\x01\x02\
\x01\x01\x12\x03X\x20'\n\x0e\n\x07\x04\x11\x03\x01\x02\x01\x03\x12\x03X*\
+\n\r\n\x06\x04\x11\x03\x01\x02\x02\x12\x03Y\x10+\n\x0e\n\x07\x04\x11\
\x03\x01\x02\x02\x04\x12\x03Y\x10\x18\n\x0e\n\x07\x04\x11\x03\x01\x02\
\x02\x05\x12\x03Y\x19\x1f\n\x0e\n\x07\x04\x11\x03\x01\x02\x02\x01\x12\
\x03Y\x20&\n\x0e\n\x07\x04\x11\x03\x01\x02\x02\x03\x12\x03Y)*\n\r\n\x06\
\x04\x11\x03\x01\x02\x03\x12\x03Z\x100\n\x0e\n\x07\x04\x11\x03\x01\x02\
\x03\x04\x12\x03Z\x10\x18\n\x0e\n\x07\x04\x11\x03\x01\x02\x03\x05\x12\
\x03Z\x19\x1e\n\x0e\n\x07\x04\x11\x03\x01\x02\x03\x01\x12\x03Z\x1f+\n\
\x0e\n\x07\x04\x11\x03\x01\x02\x03\x03\x12\x03Z./\n\r\n\x06\x04\x11\x03\
\x01\x02\x04\x12\x03[\x103\n\x0e\n\x07\x04\x11\x03\x01\x02\x04\x04\x12\
\x03[\x10\x18\n\x0e\n\x07\x04\x11\x03\x01\x02\x04\x05\x12\x03[\x19\x1e\n\
\x0e\n\x07\x04\x11\x03\x01\x02\x04\x01\x12\x03[\x1f.\n\x0e\n\x07\x04\x11\
\x03\x01\x02\x04\x03\x12\x03[12\n\r\n\x06\x04\x11\x03\x01\x02\x05\x12\
\x03\\\x10-\n\x0e\n\x07\x04\x11\x03\x01\x02\x05\x04\x12\x03\\\x10\x18\n\
\x0e\n\x07\x04\x11\x03\x01\x02\x05\x05\x12\x03\\\x19\x1f\n\x0e\n\x07\x04\
\x11\x03\x01\x02\x05\x01\x12\x03\\\x20(\n\x0e\n\x07\x04\x11\x03\x01\x02\
\x05\x03\x12\x03\\+,\n\r\n\x06\x04\x11\x03\x01\x02\x06\x12\x03]\x101\n\
\x0e\n\x07\x04\x11\x03\x01\x02\x06\x04\x12\x03]\x10\x18\n\x0e\n\x07\x04\
\x11\x03\x01\x02\x06\x05\x12\x03]\x19\x1f\n\x0e\n\x07\x04\x11\x03\x01\
\x02\x06\x01\x12\x03]\x20,\n\x0e\n\x07\x04\x11\x03\x01\x02\x06\x03\x12\
\x03]/0\n\r\n\x06\x04\x11\x03\x01\x02\x07\x12\x03^\x100\n\x0e\n\x07\x04\
\x11\x03\x01\x02\x07\x04\x12\x03^\x10\x18\n\x0e\n\x07\x04\x11\x03\x01\
\x02\x07\x05\x12\x03^\x19\x1f\n\x0e\n\x07\x04\x11\x03\x01\x02\x07\x01\
\x12\x03^\x20+\n\x0e\n\x07\x04\x11\x03\x01\x02\x07\x03\x12\x03^./\n\r\n\
\x06\x04\x11\x03\x01\x02\x08\x12\x03_\x10/\n\x0e\n\x07\x04\x11\x03\x01\
\x02\x08\x04\x12\x03_\x10\x18\n\x0e\n\x07\x04\x11\x03\x01\x02\x08\x05\
\x12\x03_\x19\x1f\n\x0e\n\x07\x04\x11\x03\x01\x02\x08\x01\x12\x03_\x20*\
\n\x0e\n\x07\x04\x11\x03\x01\x02\x08\x03\x12\x03_-.\n\x0b\n\x04\x04\x11\
\x02\0\x12\x03b\x08L\n\x0c\n\x05\x04\x11\x02\0\x04\x12\x03b\x08\x10\n\
\x0c\n\x05\x04\x11\x02\0\x06\x12\x03b\x11?\n\x0c\n\x05\x04\x11\x02\0\x01\
\x12\x03b@G\n\x0c\n\x05\x04\x11\x02\0\x03\x12\x03bJK\n\x0b\n\x04\x04\x11\
\x02\x01\x12\x03c\x08J\n\x0c\n\x05\x04\x11\x02\x01\x04\x12\x03c\x08\x10\
\n\x0c\n\x05\x04\x11\x02\x01\x06\x12\x03c\x11<\n\x0c\n\x05\x04\x11\x02\
\x01\x01\x12\x03c=E\n\x0c\n\x05\x04\x11\x02\x01\x03\x12\x03cHI\n\n\n\x02\
\x04\x12\x12\x04f\0g\x01\n\n\n\x03\x04\x12\x01\x12\x03f\x08/\n\n\n\x02\
\x04\x13\x12\x04i\0t\x01\n\n\n\x03\x04\x13\x01\x12\x03i\x080\n\x0b\n\x04\
\x04\x13\x02\0\x12\x03j\x08\"\n\x0c\n\x05\x04\x13\x02\0\x04\x12\x03j\x08\
\x10\n\x0c\n\x05\x04\x13\x02\0\x05\x12\x03j\x11\x15\n\x0c\n\x05\x04\x13\
\x02\0\x01\x12\x03j\x16\x1d\n\x0c\n\x05\x04\x13\x02\0\x03\x12\x03j\x20!\
\n\x0b\n\x04\x04\x13\x02\x01\x12\x03k\x08!\n\x0c\n\x05\x04\x13\x02\x01\
\x04\x12\x03k\x08\x10\n\x0c\n\x05\x04\x13\x02\x01\x05\x12\x03k\x11\x17\n\
\x0c\n\x05\x04\x13\x02\x01\x01\x12\x03k\x18\x1c\n\x0c\n\x05\x04\x13\x02\
\x01\x03\x12\x03k\x1f\x20\n\x0b\n\x04\x04\x13\x02\x02\x12\x03l\x08+\n\
\x0c\n\x05\x04\x13\x02\x02\x04\x12\x03l\x08\x10\n\x0c\n\x05\x04\x13\x02\
\x02\x05\x12\x03l\x11\x17\n\x0c\n\x05\x04\x13\x02\x02\x01\x12\x03l\x18&\
\n\x0c\n\x05\x04\x13\x02\x02\x03\x12\x03l)*\n\x0b\n\x04\x04\x13\x02\x03\
\x12\x03m\x08(\n\x0c\n\x05\x04\x13\x02\x03\x04\x12\x03m\x08\x10\n\x0c\n\
\x05\x04\x13\x02\x03\x05\x12\x03m\x11\x17\n\x0c\n\x05\x04\x13\x02\x03\
\x01\x12\x03m\x18#\n\x0c\n\x05\x04\x13\x02\x03\x03\x12\x03m&'\n\x0b\n\
\x04\x04\x13\x02\x04\x12\x03n\x08&\n\x0c\n\x05\x04\x13\x02\x04\x04\x12\
\x03n\x08\x10\n\x0c\n\x05\x04\x13\x02\x04\x05\x12\x03n\x11\x15\n\x0c\n\
\x05\x04\x13\x02\x04\x01\x12\x03n\x16!\n\x0c\n\x05\x04\x13\x02\x04\x03\
\x12\x03n$%\n\x0b\n\x04\x04\x13\x02\x05\x12\x03o\x080\n\x0c\n\x05\x04\
\x13\x02\x05\x04\x12\x03o\x08\x10\n\x0c\n\x05\x04\x13\x02\x05\x05\x12\
\x03o\x11\x17\n\x0c\n\x05\x04\x13\x02\x05\x01\x12\x03o\x18+\n\x0c\n\x05\
\x04\x13\x02\x05\x03\x12\x03o./\n\x0b\n\x04\x04\x13\x02\x06\x12\x03p\x08\
,\n\x0c\n\x05\x04\x13\x02\x06\x04\x12\x03p\x08\x10\n\x0c\n\x05\x04\x13\
\x02\x06\x05\x12\x03p\x11\x15\n\x0c\n\x05\x04\x13\x02\x06\x01\x12\x03p\
\x16&\n\x0c\n\x05\x04\x13\x02\x06\x03\x12\x03p)+\n\x0b\n\x04\x04\x13\x02\
\x07\x12\x03q\x08,\n\x0c\n\x05\x04\x13\x02\x07\x04\x12\x03q\x08\x10\n\
\x0c\n\x05\x04\x13\x02\x07\x05\x12\x03q\x11\x17\n\x0c\n\x05\x04\x13\x02\
\x07\x01\x12\x03q\x18'\n\x0c\n\x05\x04\x13\x02\x07\x03\x12\x03q*+\n\x0b\
\n\x04\x04\x13\x02\x08\x12\x03r\x08'\n\x0c\n\x05\x04\x13\x02\x08\x04\x12\
\x03r\x08\x10\n\x0c\n\x05\x04\x13\x02\x08\x05\x12\x03r\x11\x17\n\x0c\n\
\x05\x04\x13\x02\x08\x01\x12\x03r\x18\"\n\x0c\n\x05\x04\x13\x02\x08\x03\
\x12\x03r%&\n\x0b\n\x04\x04\x13\x02\t\x12\x03s\x08/\n\x0c\n\x05\x04\x13\
\x02\t\x04\x12\x03s\x08\x10\n\x0c\n\x05\x04\x13\x02\t\x05\x12\x03s\x11\
\x17\n\x0c\n\x05\x04\x13\x02\t\x01\x12\x03s\x18*\n\x0c\n\x05\x04\x13\x02\
\t\x03\x12\x03s-.\n\n\n\x02\x04\x14\x12\x04v\0~\x01\n\n\n\x03\x04\x14\
\x01\x12\x03v\x08/\n\x0b\n\x04\x04\x14\x02\0\x12\x03w\x08\"\n\x0c\n\x05\
\x04\x14\x02\0\x04\x12\x03w\x08\x10\n\x0c\n\x05\x04\x14\x02\0\x05\x12\
\x03w\x11\x15\n\x0c\n\x05\x04\x14\x02\0\x01\x12\x03w\x16\x1d\n\x0c\n\x05\
\x04\x14\x02\0\x03\x12\x03w\x20!\n\x0b\n\x04\x04\x14\x02\x01\x12\x03x\
\x08!\n\x0c\n\x05\x04\x14\x02\x01\x04\x12\x03x\x08\x10\n\x0c\n\x05\x04\
\x14\x02\x01\x05\x12\x03x\x11\x17\n\x0c\n\x05\x04\x14\x02\x01\x01\x12\
\x03x\x18\x1c\n\x0c\n\x05\x04\x14\x02\x01\x03\x12\x03x\x1f\x20\n\x0b\n\
\x04\x04\x14\x02\x02\x12\x03y\x08+\n\x0c\n\x05\x04\x14\x02\x02\x04\x12\
\x03y\x08\x10\n\x0c\n\x05\x04\x14\x02\x02\x05\x12\x03y\x11\x17\n\x0c\n\
\x05\x04\x14\x02\x02\x01\x12\x03y\x18&\n\x0c\n\x05\x04\x14\x02\x02\x03\
\x12\x03y)*\n\x0b\n\x04\x04\x14\x02\x03\x12\x03z\x08(\n\x0c\n\x05\x04\
\x14\x02\x03\x04\x12\x03z\x08\x10\n\x0c\n\x05\x04\x14\x02\x03\x05\x12\
\x03z\x11\x17\n\x0c\n\x05\x04\x14\x02\x03\x01\x12\x03z\x18#\n\x0c\n\x05\
\x04\x14\x02\x03\x03\x12\x03z&'\n\x0b\n\x04\x04\x14\x02\x04\x12\x03{\x08\
&\n\x0c\n\x05\x04\x14\x02\x04\x04\x12\x03{\x08\x10\n\x0c\n\x05\x04\x14\
\x02\x04\x05\x12\x03{\x11\x15\n\x0c\n\x05\x04\x14\x02\x04\x01\x12\x03{\
\x16!\n\x0c\n\x05\x04\x14\x02\x04\x03\x12\x03{$%\n\x0b\n\x04\x04\x14\x02\
\x05\x12\x03|\x08+\n\x0c\n\x05\x04\x14\x02\x05\x04\x12\x03|\x08\x10\n\
\x0c\n\x05\x04\x14\x02\x05\x05\x12\x03|\x11\x15\n\x0c\n\x05\x04\x14\x02\
\x05\x01\x12\x03|\x16&\n\x0c\n\x05\x04\x14\x02\x05\x03\x12\x03|)*\n\x0b\
\n\x04\x04\x14\x02\x06\x12\x03}\x080\n\x0c\n\x05\x04\x14\x02\x06\x04\x12\
\x03}\x08\x10\n\x0c\n\x05\x04\x14\x02\x06\x05\x12\x03}\x11\x17\n\x0c\n\
\x05\x04\x14\x02\x06\x01\x12\x03}\x18+\n\x0c\n\x05\x04\x14\x02\x06\x03\
\x12\x03}./\n\x0c\n\x02\x04\x15\x12\x06\x80\x01\0\x81\x01\x01\n\x0b\n\
\x03\x04\x15\x01\x12\x04\x80\x01\x080\
";
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()
})
}