// This file is generated. Do not edit // @generated // https://github.com/Manishearth/rust-clippy/issues/702 #![allow(unknown_lints)] #![allow(clippy)] #![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(unsafe_code)] #![allow(unused_imports)] #![allow(unused_results)] use protobuf::Message as Message_imported_for_functions; use protobuf::ProtobufEnum as ProtobufEnum_imported_for_functions; #[derive(PartialEq,Clone,Default)] pub struct ClientResponseEncrypted { // message fields login_credentials: ::protobuf::SingularPtrField, account_creation: ::std::option::Option, fingerprint_response: ::protobuf::SingularPtrField, peer_ticket: ::protobuf::SingularPtrField, system_info: ::protobuf::SingularPtrField, platform_model: ::protobuf::SingularField<::std::string::String>, version_string: ::protobuf::SingularField<::std::string::String>, appkey: ::protobuf::SingularPtrField, client_info: ::protobuf::SingularPtrField, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for ClientResponseEncrypted {} impl ClientResponseEncrypted { pub fn new() -> ClientResponseEncrypted { ::std::default::Default::default() } pub fn default_instance() -> &'static ClientResponseEncrypted { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ClientResponseEncrypted, }; unsafe { instance.get(ClientResponseEncrypted::new) } } // required .LoginCredentials login_credentials = 10; pub fn clear_login_credentials(&mut self) { self.login_credentials.clear(); } pub fn has_login_credentials(&self) -> bool { self.login_credentials.is_some() } // Param is passed by value, moved pub fn set_login_credentials(&mut self, v: LoginCredentials) { self.login_credentials = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_login_credentials(&mut self) -> &mut LoginCredentials { if self.login_credentials.is_none() { self.login_credentials.set_default(); } self.login_credentials.as_mut().unwrap() } // Take field pub fn take_login_credentials(&mut self) -> LoginCredentials { self.login_credentials.take().unwrap_or_else(|| LoginCredentials::new()) } pub fn get_login_credentials(&self) -> &LoginCredentials { self.login_credentials.as_ref().unwrap_or_else(|| LoginCredentials::default_instance()) } fn get_login_credentials_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.login_credentials } fn mut_login_credentials_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.login_credentials } // optional .AccountCreation account_creation = 20; pub fn clear_account_creation(&mut self) { self.account_creation = ::std::option::Option::None; } pub fn has_account_creation(&self) -> bool { self.account_creation.is_some() } // Param is passed by value, moved pub fn set_account_creation(&mut self, v: AccountCreation) { self.account_creation = ::std::option::Option::Some(v); } pub fn get_account_creation(&self) -> AccountCreation { self.account_creation.unwrap_or(AccountCreation::ACCOUNT_CREATION_ALWAYS_PROMPT) } fn get_account_creation_for_reflect(&self) -> &::std::option::Option { &self.account_creation } fn mut_account_creation_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.account_creation } // optional .FingerprintResponseUnion fingerprint_response = 30; pub fn clear_fingerprint_response(&mut self) { self.fingerprint_response.clear(); } pub fn has_fingerprint_response(&self) -> bool { self.fingerprint_response.is_some() } // Param is passed by value, moved pub fn set_fingerprint_response(&mut self, v: FingerprintResponseUnion) { self.fingerprint_response = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_fingerprint_response(&mut self) -> &mut FingerprintResponseUnion { if self.fingerprint_response.is_none() { self.fingerprint_response.set_default(); } self.fingerprint_response.as_mut().unwrap() } // Take field pub fn take_fingerprint_response(&mut self) -> FingerprintResponseUnion { self.fingerprint_response.take().unwrap_or_else(|| FingerprintResponseUnion::new()) } pub fn get_fingerprint_response(&self) -> &FingerprintResponseUnion { self.fingerprint_response.as_ref().unwrap_or_else(|| FingerprintResponseUnion::default_instance()) } fn get_fingerprint_response_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.fingerprint_response } fn mut_fingerprint_response_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.fingerprint_response } // optional .PeerTicketUnion peer_ticket = 40; pub fn clear_peer_ticket(&mut self) { self.peer_ticket.clear(); } pub fn has_peer_ticket(&self) -> bool { self.peer_ticket.is_some() } // Param is passed by value, moved pub fn set_peer_ticket(&mut self, v: PeerTicketUnion) { self.peer_ticket = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_peer_ticket(&mut self) -> &mut PeerTicketUnion { if self.peer_ticket.is_none() { self.peer_ticket.set_default(); } self.peer_ticket.as_mut().unwrap() } // Take field pub fn take_peer_ticket(&mut self) -> PeerTicketUnion { self.peer_ticket.take().unwrap_or_else(|| PeerTicketUnion::new()) } pub fn get_peer_ticket(&self) -> &PeerTicketUnion { self.peer_ticket.as_ref().unwrap_or_else(|| PeerTicketUnion::default_instance()) } fn get_peer_ticket_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.peer_ticket } fn mut_peer_ticket_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.peer_ticket } // required .SystemInfo system_info = 50; pub fn clear_system_info(&mut self) { self.system_info.clear(); } pub fn has_system_info(&self) -> bool { self.system_info.is_some() } // Param is passed by value, moved pub fn set_system_info(&mut self, v: SystemInfo) { self.system_info = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_system_info(&mut self) -> &mut SystemInfo { if self.system_info.is_none() { self.system_info.set_default(); } self.system_info.as_mut().unwrap() } // Take field pub fn take_system_info(&mut self) -> SystemInfo { self.system_info.take().unwrap_or_else(|| SystemInfo::new()) } pub fn get_system_info(&self) -> &SystemInfo { self.system_info.as_ref().unwrap_or_else(|| SystemInfo::default_instance()) } fn get_system_info_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.system_info } fn mut_system_info_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.system_info } // optional string platform_model = 60; pub fn clear_platform_model(&mut self) { self.platform_model.clear(); } pub fn has_platform_model(&self) -> bool { self.platform_model.is_some() } // Param is passed by value, moved pub fn set_platform_model(&mut self, v: ::std::string::String) { self.platform_model = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_platform_model(&mut self) -> &mut ::std::string::String { if self.platform_model.is_none() { self.platform_model.set_default(); } self.platform_model.as_mut().unwrap() } // Take field pub fn take_platform_model(&mut self) -> ::std::string::String { self.platform_model.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_platform_model(&self) -> &str { match self.platform_model.as_ref() { Some(v) => &v, None => "", } } fn get_platform_model_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.platform_model } fn mut_platform_model_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.platform_model } // optional string version_string = 70; pub fn clear_version_string(&mut self) { self.version_string.clear(); } pub fn has_version_string(&self) -> bool { self.version_string.is_some() } // Param is passed by value, moved pub fn set_version_string(&mut self, v: ::std::string::String) { self.version_string = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_version_string(&mut self) -> &mut ::std::string::String { if self.version_string.is_none() { self.version_string.set_default(); } self.version_string.as_mut().unwrap() } // Take field pub fn take_version_string(&mut self) -> ::std::string::String { self.version_string.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_version_string(&self) -> &str { match self.version_string.as_ref() { Some(v) => &v, None => "", } } fn get_version_string_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.version_string } fn mut_version_string_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.version_string } // optional .LibspotifyAppKey appkey = 80; pub fn clear_appkey(&mut self) { self.appkey.clear(); } pub fn has_appkey(&self) -> bool { self.appkey.is_some() } // Param is passed by value, moved pub fn set_appkey(&mut self, v: LibspotifyAppKey) { self.appkey = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_appkey(&mut self) -> &mut LibspotifyAppKey { if self.appkey.is_none() { self.appkey.set_default(); } self.appkey.as_mut().unwrap() } // Take field pub fn take_appkey(&mut self) -> LibspotifyAppKey { self.appkey.take().unwrap_or_else(|| LibspotifyAppKey::new()) } pub fn get_appkey(&self) -> &LibspotifyAppKey { self.appkey.as_ref().unwrap_or_else(|| LibspotifyAppKey::default_instance()) } fn get_appkey_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.appkey } fn mut_appkey_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.appkey } // optional .ClientInfo client_info = 90; pub fn clear_client_info(&mut self) { self.client_info.clear(); } pub fn has_client_info(&self) -> bool { self.client_info.is_some() } // Param is passed by value, moved pub fn set_client_info(&mut self, v: ClientInfo) { self.client_info = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_client_info(&mut self) -> &mut ClientInfo { if self.client_info.is_none() { self.client_info.set_default(); } self.client_info.as_mut().unwrap() } // Take field pub fn take_client_info(&mut self) -> ClientInfo { self.client_info.take().unwrap_or_else(|| ClientInfo::new()) } pub fn get_client_info(&self) -> &ClientInfo { self.client_info.as_ref().unwrap_or_else(|| ClientInfo::default_instance()) } fn get_client_info_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.client_info } fn mut_client_info_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.client_info } } impl ::protobuf::Message for ClientResponseEncrypted { fn is_initialized(&self) -> bool { if self.login_credentials.is_none() { return false; } if self.system_info.is_none() { return false; } for v in &self.login_credentials { if !v.is_initialized() { return false; } }; for v in &self.fingerprint_response { if !v.is_initialized() { return false; } }; for v in &self.peer_ticket { if !v.is_initialized() { return false; } }; for v in &self.system_info { if !v.is_initialized() { return false; } }; for v in &self.appkey { if !v.is_initialized() { return false; } }; for v in &self.client_info { 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 { 10 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.login_credentials)?; }, 20 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.account_creation = ::std::option::Option::Some(tmp); }, 30 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fingerprint_response)?; }, 40 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.peer_ticket)?; }, 50 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.system_info)?; }, 60 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.platform_model)?; }, 70 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.version_string)?; }, 80 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.appkey)?; }, 90 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.client_info)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.login_credentials.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(v) = self.account_creation { my_size += ::protobuf::rt::enum_size(20, v); } if let Some(ref v) = self.fingerprint_response.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.peer_ticket.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.system_info.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.platform_model.as_ref() { my_size += ::protobuf::rt::string_size(60, &v); } if let Some(ref v) = self.version_string.as_ref() { my_size += ::protobuf::rt::string_size(70, &v); } if let Some(ref v) = self.appkey.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.client_info.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(ref v) = self.login_credentials.as_ref() { os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(v) = self.account_creation { os.write_enum(20, v.value())?; } if let Some(ref v) = self.fingerprint_response.as_ref() { os.write_tag(30, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.peer_ticket.as_ref() { os.write_tag(40, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.system_info.as_ref() { os.write_tag(50, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.platform_model.as_ref() { os.write_string(60, &v)?; } if let Some(ref v) = self.version_string.as_ref() { os.write_string(70, &v)?; } if let Some(ref v) = self.appkey.as_ref() { os.write_tag(80, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.client_info.as_ref() { os.write_tag(90, ::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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for ClientResponseEncrypted { fn new() -> ClientResponseEncrypted { ClientResponseEncrypted::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "login_credentials", ClientResponseEncrypted::get_login_credentials_for_reflect, ClientResponseEncrypted::mut_login_credentials_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "account_creation", ClientResponseEncrypted::get_account_creation_for_reflect, ClientResponseEncrypted::mut_account_creation_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "fingerprint_response", ClientResponseEncrypted::get_fingerprint_response_for_reflect, ClientResponseEncrypted::mut_fingerprint_response_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "peer_ticket", ClientResponseEncrypted::get_peer_ticket_for_reflect, ClientResponseEncrypted::mut_peer_ticket_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "system_info", ClientResponseEncrypted::get_system_info_for_reflect, ClientResponseEncrypted::mut_system_info_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "platform_model", ClientResponseEncrypted::get_platform_model_for_reflect, ClientResponseEncrypted::mut_platform_model_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "version_string", ClientResponseEncrypted::get_version_string_for_reflect, ClientResponseEncrypted::mut_version_string_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "appkey", ClientResponseEncrypted::get_appkey_for_reflect, ClientResponseEncrypted::mut_appkey_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "client_info", ClientResponseEncrypted::get_client_info_for_reflect, ClientResponseEncrypted::mut_client_info_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "ClientResponseEncrypted", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for ClientResponseEncrypted { fn clear(&mut self) { self.clear_login_credentials(); self.clear_account_creation(); self.clear_fingerprint_response(); self.clear_peer_ticket(); self.clear_system_info(); self.clear_platform_model(); self.clear_version_string(); self.clear_appkey(); self.clear_client_info(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for ClientResponseEncrypted { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for ClientResponseEncrypted { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct LoginCredentials { // message fields username: ::protobuf::SingularField<::std::string::String>, typ: ::std::option::Option, auth_data: ::protobuf::SingularField<::std::vec::Vec>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for LoginCredentials {} impl LoginCredentials { pub fn new() -> LoginCredentials { ::std::default::Default::default() } pub fn default_instance() -> &'static LoginCredentials { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const LoginCredentials, }; unsafe { instance.get(LoginCredentials::new) } } // optional string username = 10; pub fn clear_username(&mut self) { self.username.clear(); } pub fn has_username(&self) -> bool { self.username.is_some() } // Param is passed by value, moved pub fn set_username(&mut self, v: ::std::string::String) { self.username = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_username(&mut self) -> &mut ::std::string::String { if self.username.is_none() { self.username.set_default(); } self.username.as_mut().unwrap() } // Take field pub fn take_username(&mut self) -> ::std::string::String { self.username.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_username(&self) -> &str { match self.username.as_ref() { Some(v) => &v, None => "", } } fn get_username_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.username } fn mut_username_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.username } // required .AuthenticationType typ = 20; pub fn clear_typ(&mut self) { self.typ = ::std::option::Option::None; } pub fn has_typ(&self) -> bool { self.typ.is_some() } // Param is passed by value, moved pub fn set_typ(&mut self, v: AuthenticationType) { self.typ = ::std::option::Option::Some(v); } pub fn get_typ(&self) -> AuthenticationType { self.typ.unwrap_or(AuthenticationType::AUTHENTICATION_USER_PASS) } fn get_typ_for_reflect(&self) -> &::std::option::Option { &self.typ } fn mut_typ_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.typ } // optional bytes auth_data = 30; pub fn clear_auth_data(&mut self) { self.auth_data.clear(); } pub fn has_auth_data(&self) -> bool { self.auth_data.is_some() } // Param is passed by value, moved pub fn set_auth_data(&mut self, v: ::std::vec::Vec) { self.auth_data = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_auth_data(&mut self) -> &mut ::std::vec::Vec { if self.auth_data.is_none() { self.auth_data.set_default(); } self.auth_data.as_mut().unwrap() } // Take field pub fn take_auth_data(&mut self) -> ::std::vec::Vec { self.auth_data.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_auth_data(&self) -> &[u8] { match self.auth_data.as_ref() { Some(v) => &v, None => &[], } } fn get_auth_data_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.auth_data } fn mut_auth_data_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.auth_data } } impl ::protobuf::Message for LoginCredentials { fn is_initialized(&self) -> bool { if self.typ.is_none() { 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 { 10 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.username)?; }, 20 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.typ = ::std::option::Option::Some(tmp); }, 30 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.auth_data)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[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(10, &v); } if let Some(v) = self.typ { my_size += ::protobuf::rt::enum_size(20, v); } if let Some(ref v) = self.auth_data.as_ref() { my_size += ::protobuf::rt::bytes_size(30, &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.username.as_ref() { os.write_string(10, &v)?; } if let Some(v) = self.typ { os.write_enum(20, v.value())?; } if let Some(ref v) = self.auth_data.as_ref() { os.write_bytes(30, &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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for LoginCredentials { fn new() -> LoginCredentials { LoginCredentials::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "username", LoginCredentials::get_username_for_reflect, LoginCredentials::mut_username_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "typ", LoginCredentials::get_typ_for_reflect, LoginCredentials::mut_typ_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "auth_data", LoginCredentials::get_auth_data_for_reflect, LoginCredentials::mut_auth_data_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "LoginCredentials", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for LoginCredentials { fn clear(&mut self) { self.clear_username(); self.clear_typ(); self.clear_auth_data(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for LoginCredentials { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for LoginCredentials { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct FingerprintResponseUnion { // message fields grain: ::protobuf::SingularPtrField, hmac_ripemd: ::protobuf::SingularPtrField, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for FingerprintResponseUnion {} impl FingerprintResponseUnion { pub fn new() -> FingerprintResponseUnion { ::std::default::Default::default() } pub fn default_instance() -> &'static FingerprintResponseUnion { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FingerprintResponseUnion, }; unsafe { instance.get(FingerprintResponseUnion::new) } } // optional .FingerprintGrainResponse grain = 10; pub fn clear_grain(&mut self) { self.grain.clear(); } pub fn has_grain(&self) -> bool { self.grain.is_some() } // Param is passed by value, moved pub fn set_grain(&mut self, v: FingerprintGrainResponse) { self.grain = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_grain(&mut self) -> &mut FingerprintGrainResponse { if self.grain.is_none() { self.grain.set_default(); } self.grain.as_mut().unwrap() } // Take field pub fn take_grain(&mut self) -> FingerprintGrainResponse { self.grain.take().unwrap_or_else(|| FingerprintGrainResponse::new()) } pub fn get_grain(&self) -> &FingerprintGrainResponse { self.grain.as_ref().unwrap_or_else(|| FingerprintGrainResponse::default_instance()) } fn get_grain_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.grain } fn mut_grain_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.grain } // optional .FingerprintHmacRipemdResponse hmac_ripemd = 20; pub fn clear_hmac_ripemd(&mut self) { self.hmac_ripemd.clear(); } pub fn has_hmac_ripemd(&self) -> bool { self.hmac_ripemd.is_some() } // Param is passed by value, moved pub fn set_hmac_ripemd(&mut self, v: FingerprintHmacRipemdResponse) { self.hmac_ripemd = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_hmac_ripemd(&mut self) -> &mut FingerprintHmacRipemdResponse { if self.hmac_ripemd.is_none() { self.hmac_ripemd.set_default(); } self.hmac_ripemd.as_mut().unwrap() } // Take field pub fn take_hmac_ripemd(&mut self) -> FingerprintHmacRipemdResponse { self.hmac_ripemd.take().unwrap_or_else(|| FingerprintHmacRipemdResponse::new()) } pub fn get_hmac_ripemd(&self) -> &FingerprintHmacRipemdResponse { self.hmac_ripemd.as_ref().unwrap_or_else(|| FingerprintHmacRipemdResponse::default_instance()) } fn get_hmac_ripemd_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.hmac_ripemd } fn mut_hmac_ripemd_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.hmac_ripemd } } impl ::protobuf::Message for FingerprintResponseUnion { fn is_initialized(&self) -> bool { for v in &self.grain { if !v.is_initialized() { return false; } }; for v in &self.hmac_ripemd { 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 { 10 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.grain)?; }, 20 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.hmac_ripemd)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.grain.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.hmac_ripemd.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(ref v) = self.grain.as_ref() { os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.hmac_ripemd.as_ref() { os.write_tag(20, ::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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for FingerprintResponseUnion { fn new() -> FingerprintResponseUnion { FingerprintResponseUnion::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "grain", FingerprintResponseUnion::get_grain_for_reflect, FingerprintResponseUnion::mut_grain_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "hmac_ripemd", FingerprintResponseUnion::get_hmac_ripemd_for_reflect, FingerprintResponseUnion::mut_hmac_ripemd_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "FingerprintResponseUnion", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for FingerprintResponseUnion { fn clear(&mut self) { self.clear_grain(); self.clear_hmac_ripemd(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for FingerprintResponseUnion { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for FingerprintResponseUnion { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct FingerprintGrainResponse { // message fields encrypted_key: ::protobuf::SingularField<::std::vec::Vec>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for FingerprintGrainResponse {} impl FingerprintGrainResponse { pub fn new() -> FingerprintGrainResponse { ::std::default::Default::default() } pub fn default_instance() -> &'static FingerprintGrainResponse { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FingerprintGrainResponse, }; unsafe { instance.get(FingerprintGrainResponse::new) } } // required bytes encrypted_key = 10; pub fn clear_encrypted_key(&mut self) { self.encrypted_key.clear(); } pub fn has_encrypted_key(&self) -> bool { self.encrypted_key.is_some() } // Param is passed by value, moved pub fn set_encrypted_key(&mut self, v: ::std::vec::Vec) { self.encrypted_key = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_encrypted_key(&mut self) -> &mut ::std::vec::Vec { if self.encrypted_key.is_none() { self.encrypted_key.set_default(); } self.encrypted_key.as_mut().unwrap() } // Take field pub fn take_encrypted_key(&mut self) -> ::std::vec::Vec { self.encrypted_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_encrypted_key(&self) -> &[u8] { match self.encrypted_key.as_ref() { Some(v) => &v, None => &[], } } fn get_encrypted_key_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.encrypted_key } fn mut_encrypted_key_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.encrypted_key } } impl ::protobuf::Message for FingerprintGrainResponse { fn is_initialized(&self) -> bool { if self.encrypted_key.is_none() { 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 { 10 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.encrypted_key)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.encrypted_key.as_ref() { my_size += ::protobuf::rt::bytes_size(10, &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.encrypted_key.as_ref() { os.write_bytes(10, &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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for FingerprintGrainResponse { fn new() -> FingerprintGrainResponse { FingerprintGrainResponse::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "encrypted_key", FingerprintGrainResponse::get_encrypted_key_for_reflect, FingerprintGrainResponse::mut_encrypted_key_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "FingerprintGrainResponse", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for FingerprintGrainResponse { fn clear(&mut self) { self.clear_encrypted_key(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for FingerprintGrainResponse { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for FingerprintGrainResponse { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct FingerprintHmacRipemdResponse { // message fields hmac: ::protobuf::SingularField<::std::vec::Vec>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for FingerprintHmacRipemdResponse {} impl FingerprintHmacRipemdResponse { pub fn new() -> FingerprintHmacRipemdResponse { ::std::default::Default::default() } pub fn default_instance() -> &'static FingerprintHmacRipemdResponse { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const FingerprintHmacRipemdResponse, }; unsafe { instance.get(FingerprintHmacRipemdResponse::new) } } // required bytes hmac = 10; pub fn clear_hmac(&mut self) { self.hmac.clear(); } pub fn has_hmac(&self) -> bool { self.hmac.is_some() } // Param is passed by value, moved pub fn set_hmac(&mut self, v: ::std::vec::Vec) { self.hmac = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_hmac(&mut self) -> &mut ::std::vec::Vec { if self.hmac.is_none() { self.hmac.set_default(); } self.hmac.as_mut().unwrap() } // Take field pub fn take_hmac(&mut self) -> ::std::vec::Vec { self.hmac.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_hmac(&self) -> &[u8] { match self.hmac.as_ref() { Some(v) => &v, None => &[], } } fn get_hmac_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.hmac } fn mut_hmac_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.hmac } } impl ::protobuf::Message for FingerprintHmacRipemdResponse { fn is_initialized(&self) -> bool { if self.hmac.is_none() { 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 { 10 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.hmac)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.hmac.as_ref() { my_size += ::protobuf::rt::bytes_size(10, &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.hmac.as_ref() { os.write_bytes(10, &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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for FingerprintHmacRipemdResponse { fn new() -> FingerprintHmacRipemdResponse { FingerprintHmacRipemdResponse::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "hmac", FingerprintHmacRipemdResponse::get_hmac_for_reflect, FingerprintHmacRipemdResponse::mut_hmac_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "FingerprintHmacRipemdResponse", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for FingerprintHmacRipemdResponse { fn clear(&mut self) { self.clear_hmac(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for FingerprintHmacRipemdResponse { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for FingerprintHmacRipemdResponse { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct PeerTicketUnion { // message fields public_key: ::protobuf::SingularPtrField, old_ticket: ::protobuf::SingularPtrField, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for PeerTicketUnion {} impl PeerTicketUnion { pub fn new() -> PeerTicketUnion { ::std::default::Default::default() } pub fn default_instance() -> &'static PeerTicketUnion { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const PeerTicketUnion, }; unsafe { instance.get(PeerTicketUnion::new) } } // optional .PeerTicketPublicKey public_key = 10; pub fn clear_public_key(&mut self) { self.public_key.clear(); } pub fn has_public_key(&self) -> bool { self.public_key.is_some() } // Param is passed by value, moved pub fn set_public_key(&mut self, v: PeerTicketPublicKey) { self.public_key = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_public_key(&mut self) -> &mut PeerTicketPublicKey { if self.public_key.is_none() { self.public_key.set_default(); } self.public_key.as_mut().unwrap() } // Take field pub fn take_public_key(&mut self) -> PeerTicketPublicKey { self.public_key.take().unwrap_or_else(|| PeerTicketPublicKey::new()) } pub fn get_public_key(&self) -> &PeerTicketPublicKey { self.public_key.as_ref().unwrap_or_else(|| PeerTicketPublicKey::default_instance()) } fn get_public_key_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.public_key } fn mut_public_key_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.public_key } // optional .PeerTicketOld old_ticket = 20; pub fn clear_old_ticket(&mut self) { self.old_ticket.clear(); } pub fn has_old_ticket(&self) -> bool { self.old_ticket.is_some() } // Param is passed by value, moved pub fn set_old_ticket(&mut self, v: PeerTicketOld) { self.old_ticket = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_old_ticket(&mut self) -> &mut PeerTicketOld { if self.old_ticket.is_none() { self.old_ticket.set_default(); } self.old_ticket.as_mut().unwrap() } // Take field pub fn take_old_ticket(&mut self) -> PeerTicketOld { self.old_ticket.take().unwrap_or_else(|| PeerTicketOld::new()) } pub fn get_old_ticket(&self) -> &PeerTicketOld { self.old_ticket.as_ref().unwrap_or_else(|| PeerTicketOld::default_instance()) } fn get_old_ticket_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.old_ticket } fn mut_old_ticket_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.old_ticket } } impl ::protobuf::Message for PeerTicketUnion { fn is_initialized(&self) -> bool { for v in &self.public_key { if !v.is_initialized() { return false; } }; for v in &self.old_ticket { 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 { 10 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.public_key)?; }, 20 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.old_ticket)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.public_key.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.old_ticket.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(ref v) = self.public_key.as_ref() { os.write_tag(10, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.old_ticket.as_ref() { os.write_tag(20, ::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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for PeerTicketUnion { fn new() -> PeerTicketUnion { PeerTicketUnion::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "public_key", PeerTicketUnion::get_public_key_for_reflect, PeerTicketUnion::mut_public_key_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "old_ticket", PeerTicketUnion::get_old_ticket_for_reflect, PeerTicketUnion::mut_old_ticket_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "PeerTicketUnion", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for PeerTicketUnion { fn clear(&mut self) { self.clear_public_key(); self.clear_old_ticket(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for PeerTicketUnion { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for PeerTicketUnion { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct PeerTicketPublicKey { // message fields public_key: ::protobuf::SingularField<::std::vec::Vec>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for PeerTicketPublicKey {} impl PeerTicketPublicKey { pub fn new() -> PeerTicketPublicKey { ::std::default::Default::default() } pub fn default_instance() -> &'static PeerTicketPublicKey { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const PeerTicketPublicKey, }; unsafe { instance.get(PeerTicketPublicKey::new) } } // required bytes public_key = 10; pub fn clear_public_key(&mut self) { self.public_key.clear(); } pub fn has_public_key(&self) -> bool { self.public_key.is_some() } // Param is passed by value, moved pub fn set_public_key(&mut self, v: ::std::vec::Vec) { self.public_key = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_public_key(&mut self) -> &mut ::std::vec::Vec { if self.public_key.is_none() { self.public_key.set_default(); } self.public_key.as_mut().unwrap() } // Take field pub fn take_public_key(&mut self) -> ::std::vec::Vec { self.public_key.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_public_key(&self) -> &[u8] { match self.public_key.as_ref() { Some(v) => &v, None => &[], } } fn get_public_key_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.public_key } fn mut_public_key_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.public_key } } impl ::protobuf::Message for PeerTicketPublicKey { fn is_initialized(&self) -> bool { if self.public_key.is_none() { 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 { 10 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.public_key)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.public_key.as_ref() { my_size += ::protobuf::rt::bytes_size(10, &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.public_key.as_ref() { os.write_bytes(10, &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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for PeerTicketPublicKey { fn new() -> PeerTicketPublicKey { PeerTicketPublicKey::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "public_key", PeerTicketPublicKey::get_public_key_for_reflect, PeerTicketPublicKey::mut_public_key_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "PeerTicketPublicKey", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for PeerTicketPublicKey { fn clear(&mut self) { self.clear_public_key(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for PeerTicketPublicKey { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for PeerTicketPublicKey { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct PeerTicketOld { // message fields peer_ticket: ::protobuf::SingularField<::std::vec::Vec>, peer_ticket_signature: ::protobuf::SingularField<::std::vec::Vec>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for PeerTicketOld {} impl PeerTicketOld { pub fn new() -> PeerTicketOld { ::std::default::Default::default() } pub fn default_instance() -> &'static PeerTicketOld { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const PeerTicketOld, }; unsafe { instance.get(PeerTicketOld::new) } } // required bytes peer_ticket = 10; pub fn clear_peer_ticket(&mut self) { self.peer_ticket.clear(); } pub fn has_peer_ticket(&self) -> bool { self.peer_ticket.is_some() } // Param is passed by value, moved pub fn set_peer_ticket(&mut self, v: ::std::vec::Vec) { self.peer_ticket = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_peer_ticket(&mut self) -> &mut ::std::vec::Vec { if self.peer_ticket.is_none() { self.peer_ticket.set_default(); } self.peer_ticket.as_mut().unwrap() } // Take field pub fn take_peer_ticket(&mut self) -> ::std::vec::Vec { self.peer_ticket.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_peer_ticket(&self) -> &[u8] { match self.peer_ticket.as_ref() { Some(v) => &v, None => &[], } } fn get_peer_ticket_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.peer_ticket } fn mut_peer_ticket_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.peer_ticket } // required bytes peer_ticket_signature = 20; pub fn clear_peer_ticket_signature(&mut self) { self.peer_ticket_signature.clear(); } pub fn has_peer_ticket_signature(&self) -> bool { self.peer_ticket_signature.is_some() } // Param is passed by value, moved pub fn set_peer_ticket_signature(&mut self, v: ::std::vec::Vec) { self.peer_ticket_signature = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_peer_ticket_signature(&mut self) -> &mut ::std::vec::Vec { if self.peer_ticket_signature.is_none() { self.peer_ticket_signature.set_default(); } self.peer_ticket_signature.as_mut().unwrap() } // Take field pub fn take_peer_ticket_signature(&mut self) -> ::std::vec::Vec { self.peer_ticket_signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_peer_ticket_signature(&self) -> &[u8] { match self.peer_ticket_signature.as_ref() { Some(v) => &v, None => &[], } } fn get_peer_ticket_signature_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.peer_ticket_signature } fn mut_peer_ticket_signature_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.peer_ticket_signature } } impl ::protobuf::Message for PeerTicketOld { fn is_initialized(&self) -> bool { if self.peer_ticket.is_none() { return false; } if self.peer_ticket_signature.is_none() { 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 { 10 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.peer_ticket)?; }, 20 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.peer_ticket_signature)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.peer_ticket.as_ref() { my_size += ::protobuf::rt::bytes_size(10, &v); } if let Some(ref v) = self.peer_ticket_signature.as_ref() { my_size += ::protobuf::rt::bytes_size(20, &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.peer_ticket.as_ref() { os.write_bytes(10, &v)?; } if let Some(ref v) = self.peer_ticket_signature.as_ref() { os.write_bytes(20, &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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for PeerTicketOld { fn new() -> PeerTicketOld { PeerTicketOld::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "peer_ticket", PeerTicketOld::get_peer_ticket_for_reflect, PeerTicketOld::mut_peer_ticket_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "peer_ticket_signature", PeerTicketOld::get_peer_ticket_signature_for_reflect, PeerTicketOld::mut_peer_ticket_signature_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "PeerTicketOld", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for PeerTicketOld { fn clear(&mut self) { self.clear_peer_ticket(); self.clear_peer_ticket_signature(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for PeerTicketOld { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for PeerTicketOld { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct SystemInfo { // message fields cpu_family: ::std::option::Option, cpu_subtype: ::std::option::Option, cpu_ext: ::std::option::Option, brand: ::std::option::Option, brand_flags: ::std::option::Option, os: ::std::option::Option, os_version: ::std::option::Option, os_ext: ::std::option::Option, system_information_string: ::protobuf::SingularField<::std::string::String>, device_id: ::protobuf::SingularField<::std::string::String>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for SystemInfo {} impl SystemInfo { pub fn new() -> SystemInfo { ::std::default::Default::default() } pub fn default_instance() -> &'static SystemInfo { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const SystemInfo, }; unsafe { instance.get(SystemInfo::new) } } // required .CpuFamily cpu_family = 10; pub fn clear_cpu_family(&mut self) { self.cpu_family = ::std::option::Option::None; } pub fn has_cpu_family(&self) -> bool { self.cpu_family.is_some() } // Param is passed by value, moved pub fn set_cpu_family(&mut self, v: CpuFamily) { self.cpu_family = ::std::option::Option::Some(v); } pub fn get_cpu_family(&self) -> CpuFamily { self.cpu_family.unwrap_or(CpuFamily::CPU_UNKNOWN) } fn get_cpu_family_for_reflect(&self) -> &::std::option::Option { &self.cpu_family } fn mut_cpu_family_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.cpu_family } // optional uint32 cpu_subtype = 20; pub fn clear_cpu_subtype(&mut self) { self.cpu_subtype = ::std::option::Option::None; } pub fn has_cpu_subtype(&self) -> bool { self.cpu_subtype.is_some() } // Param is passed by value, moved pub fn set_cpu_subtype(&mut self, v: u32) { self.cpu_subtype = ::std::option::Option::Some(v); } pub fn get_cpu_subtype(&self) -> u32 { self.cpu_subtype.unwrap_or(0) } fn get_cpu_subtype_for_reflect(&self) -> &::std::option::Option { &self.cpu_subtype } fn mut_cpu_subtype_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.cpu_subtype } // optional uint32 cpu_ext = 30; pub fn clear_cpu_ext(&mut self) { self.cpu_ext = ::std::option::Option::None; } pub fn has_cpu_ext(&self) -> bool { self.cpu_ext.is_some() } // Param is passed by value, moved pub fn set_cpu_ext(&mut self, v: u32) { self.cpu_ext = ::std::option::Option::Some(v); } pub fn get_cpu_ext(&self) -> u32 { self.cpu_ext.unwrap_or(0) } fn get_cpu_ext_for_reflect(&self) -> &::std::option::Option { &self.cpu_ext } fn mut_cpu_ext_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.cpu_ext } // optional .Brand brand = 40; pub fn clear_brand(&mut self) { self.brand = ::std::option::Option::None; } pub fn has_brand(&self) -> bool { self.brand.is_some() } // Param is passed by value, moved pub fn set_brand(&mut self, v: Brand) { self.brand = ::std::option::Option::Some(v); } pub fn get_brand(&self) -> Brand { self.brand.unwrap_or(Brand::BRAND_UNBRANDED) } fn get_brand_for_reflect(&self) -> &::std::option::Option { &self.brand } fn mut_brand_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.brand } // optional uint32 brand_flags = 50; pub fn clear_brand_flags(&mut self) { self.brand_flags = ::std::option::Option::None; } pub fn has_brand_flags(&self) -> bool { self.brand_flags.is_some() } // Param is passed by value, moved pub fn set_brand_flags(&mut self, v: u32) { self.brand_flags = ::std::option::Option::Some(v); } pub fn get_brand_flags(&self) -> u32 { self.brand_flags.unwrap_or(0) } fn get_brand_flags_for_reflect(&self) -> &::std::option::Option { &self.brand_flags } fn mut_brand_flags_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.brand_flags } // required .Os os = 60; pub fn clear_os(&mut self) { self.os = ::std::option::Option::None; } pub fn has_os(&self) -> bool { self.os.is_some() } // Param is passed by value, moved pub fn set_os(&mut self, v: Os) { self.os = ::std::option::Option::Some(v); } pub fn get_os(&self) -> Os { self.os.unwrap_or(Os::OS_UNKNOWN) } fn get_os_for_reflect(&self) -> &::std::option::Option { &self.os } fn mut_os_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.os } // optional uint32 os_version = 70; pub fn clear_os_version(&mut self) { self.os_version = ::std::option::Option::None; } pub fn has_os_version(&self) -> bool { self.os_version.is_some() } // Param is passed by value, moved pub fn set_os_version(&mut self, v: u32) { self.os_version = ::std::option::Option::Some(v); } pub fn get_os_version(&self) -> u32 { self.os_version.unwrap_or(0) } fn get_os_version_for_reflect(&self) -> &::std::option::Option { &self.os_version } fn mut_os_version_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.os_version } // optional uint32 os_ext = 80; pub fn clear_os_ext(&mut self) { self.os_ext = ::std::option::Option::None; } pub fn has_os_ext(&self) -> bool { self.os_ext.is_some() } // Param is passed by value, moved pub fn set_os_ext(&mut self, v: u32) { self.os_ext = ::std::option::Option::Some(v); } pub fn get_os_ext(&self) -> u32 { self.os_ext.unwrap_or(0) } fn get_os_ext_for_reflect(&self) -> &::std::option::Option { &self.os_ext } fn mut_os_ext_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.os_ext } // optional string system_information_string = 90; pub fn clear_system_information_string(&mut self) { self.system_information_string.clear(); } pub fn has_system_information_string(&self) -> bool { self.system_information_string.is_some() } // Param is passed by value, moved pub fn set_system_information_string(&mut self, v: ::std::string::String) { self.system_information_string = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_system_information_string(&mut self) -> &mut ::std::string::String { if self.system_information_string.is_none() { self.system_information_string.set_default(); } self.system_information_string.as_mut().unwrap() } // Take field pub fn take_system_information_string(&mut self) -> ::std::string::String { self.system_information_string.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_system_information_string(&self) -> &str { match self.system_information_string.as_ref() { Some(v) => &v, None => "", } } fn get_system_information_string_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.system_information_string } fn mut_system_information_string_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.system_information_string } // optional string device_id = 100; pub fn clear_device_id(&mut self) { self.device_id.clear(); } pub fn has_device_id(&self) -> bool { self.device_id.is_some() } // Param is passed by value, moved pub fn set_device_id(&mut self, v: ::std::string::String) { self.device_id = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_device_id(&mut self) -> &mut ::std::string::String { if self.device_id.is_none() { self.device_id.set_default(); } self.device_id.as_mut().unwrap() } // Take field pub fn take_device_id(&mut self) -> ::std::string::String { self.device_id.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_device_id(&self) -> &str { match self.device_id.as_ref() { Some(v) => &v, None => "", } } fn get_device_id_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.device_id } fn mut_device_id_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.device_id } } impl ::protobuf::Message for SystemInfo { fn is_initialized(&self) -> bool { if self.cpu_family.is_none() { return false; } if self.os.is_none() { 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 { 10 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.cpu_family = ::std::option::Option::Some(tmp); }, 20 => { 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.cpu_subtype = ::std::option::Option::Some(tmp); }, 30 => { 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.cpu_ext = ::std::option::Option::Some(tmp); }, 40 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.brand = ::std::option::Option::Some(tmp); }, 50 => { 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.brand_flags = ::std::option::Option::Some(tmp); }, 60 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.os = ::std::option::Option::Some(tmp); }, 70 => { 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.os_version = ::std::option::Option::Some(tmp); }, 80 => { 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.os_ext = ::std::option::Option::Some(tmp); }, 90 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.system_information_string)?; }, 100 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.device_id)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(v) = self.cpu_family { my_size += ::protobuf::rt::enum_size(10, v); } if let Some(v) = self.cpu_subtype { my_size += ::protobuf::rt::value_size(20, v, ::protobuf::wire_format::WireTypeVarint); } if let Some(v) = self.cpu_ext { my_size += ::protobuf::rt::value_size(30, v, ::protobuf::wire_format::WireTypeVarint); } if let Some(v) = self.brand { my_size += ::protobuf::rt::enum_size(40, v); } if let Some(v) = self.brand_flags { my_size += ::protobuf::rt::value_size(50, v, ::protobuf::wire_format::WireTypeVarint); } if let Some(v) = self.os { my_size += ::protobuf::rt::enum_size(60, v); } if let Some(v) = self.os_version { my_size += ::protobuf::rt::value_size(70, v, ::protobuf::wire_format::WireTypeVarint); } if let Some(v) = self.os_ext { my_size += ::protobuf::rt::value_size(80, v, ::protobuf::wire_format::WireTypeVarint); } if let Some(ref v) = self.system_information_string.as_ref() { my_size += ::protobuf::rt::string_size(90, &v); } if let Some(ref v) = self.device_id.as_ref() { my_size += ::protobuf::rt::string_size(100, &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.cpu_family { os.write_enum(10, v.value())?; } if let Some(v) = self.cpu_subtype { os.write_uint32(20, v)?; } if let Some(v) = self.cpu_ext { os.write_uint32(30, v)?; } if let Some(v) = self.brand { os.write_enum(40, v.value())?; } if let Some(v) = self.brand_flags { os.write_uint32(50, v)?; } if let Some(v) = self.os { os.write_enum(60, v.value())?; } if let Some(v) = self.os_version { os.write_uint32(70, v)?; } if let Some(v) = self.os_ext { os.write_uint32(80, v)?; } if let Some(ref v) = self.system_information_string.as_ref() { os.write_string(90, &v)?; } if let Some(ref v) = self.device_id.as_ref() { os.write_string(100, &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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for SystemInfo { fn new() -> SystemInfo { SystemInfo::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "cpu_family", SystemInfo::get_cpu_family_for_reflect, SystemInfo::mut_cpu_family_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( "cpu_subtype", SystemInfo::get_cpu_subtype_for_reflect, SystemInfo::mut_cpu_subtype_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( "cpu_ext", SystemInfo::get_cpu_ext_for_reflect, SystemInfo::mut_cpu_ext_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "brand", SystemInfo::get_brand_for_reflect, SystemInfo::mut_brand_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( "brand_flags", SystemInfo::get_brand_flags_for_reflect, SystemInfo::mut_brand_flags_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "os", SystemInfo::get_os_for_reflect, SystemInfo::mut_os_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( "os_version", SystemInfo::get_os_version_for_reflect, SystemInfo::mut_os_version_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( "os_ext", SystemInfo::get_os_ext_for_reflect, SystemInfo::mut_os_ext_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "system_information_string", SystemInfo::get_system_information_string_for_reflect, SystemInfo::mut_system_information_string_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "device_id", SystemInfo::get_device_id_for_reflect, SystemInfo::mut_device_id_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "SystemInfo", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for SystemInfo { fn clear(&mut self) { self.clear_cpu_family(); self.clear_cpu_subtype(); self.clear_cpu_ext(); self.clear_brand(); self.clear_brand_flags(); self.clear_os(); self.clear_os_version(); self.clear_os_ext(); self.clear_system_information_string(); self.clear_device_id(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for SystemInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for SystemInfo { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct LibspotifyAppKey { // message fields version: ::std::option::Option, devkey: ::protobuf::SingularField<::std::vec::Vec>, signature: ::protobuf::SingularField<::std::vec::Vec>, useragent: ::protobuf::SingularField<::std::string::String>, callback_hash: ::protobuf::SingularField<::std::vec::Vec>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for LibspotifyAppKey {} impl LibspotifyAppKey { pub fn new() -> LibspotifyAppKey { ::std::default::Default::default() } pub fn default_instance() -> &'static LibspotifyAppKey { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const LibspotifyAppKey, }; unsafe { instance.get(LibspotifyAppKey::new) } } // required uint32 version = 1; pub fn clear_version(&mut self) { self.version = ::std::option::Option::None; } pub fn has_version(&self) -> bool { self.version.is_some() } // Param is passed by value, moved pub fn set_version(&mut self, v: u32) { self.version = ::std::option::Option::Some(v); } pub fn get_version(&self) -> u32 { self.version.unwrap_or(0) } fn get_version_for_reflect(&self) -> &::std::option::Option { &self.version } fn mut_version_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.version } // required bytes devkey = 2; pub fn clear_devkey(&mut self) { self.devkey.clear(); } pub fn has_devkey(&self) -> bool { self.devkey.is_some() } // Param is passed by value, moved pub fn set_devkey(&mut self, v: ::std::vec::Vec) { self.devkey = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_devkey(&mut self) -> &mut ::std::vec::Vec { if self.devkey.is_none() { self.devkey.set_default(); } self.devkey.as_mut().unwrap() } // Take field pub fn take_devkey(&mut self) -> ::std::vec::Vec { self.devkey.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_devkey(&self) -> &[u8] { match self.devkey.as_ref() { Some(v) => &v, None => &[], } } fn get_devkey_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.devkey } fn mut_devkey_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.devkey } // required bytes signature = 3; pub fn clear_signature(&mut self) { self.signature.clear(); } pub fn has_signature(&self) -> bool { self.signature.is_some() } // Param is passed by value, moved pub fn set_signature(&mut self, v: ::std::vec::Vec) { self.signature = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_signature(&mut self) -> &mut ::std::vec::Vec { if self.signature.is_none() { self.signature.set_default(); } self.signature.as_mut().unwrap() } // Take field pub fn take_signature(&mut self) -> ::std::vec::Vec { self.signature.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_signature(&self) -> &[u8] { match self.signature.as_ref() { Some(v) => &v, None => &[], } } fn get_signature_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.signature } fn mut_signature_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.signature } // required string useragent = 4; pub fn clear_useragent(&mut self) { self.useragent.clear(); } pub fn has_useragent(&self) -> bool { self.useragent.is_some() } // Param is passed by value, moved pub fn set_useragent(&mut self, v: ::std::string::String) { self.useragent = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_useragent(&mut self) -> &mut ::std::string::String { if self.useragent.is_none() { self.useragent.set_default(); } self.useragent.as_mut().unwrap() } // Take field pub fn take_useragent(&mut self) -> ::std::string::String { self.useragent.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_useragent(&self) -> &str { match self.useragent.as_ref() { Some(v) => &v, None => "", } } fn get_useragent_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.useragent } fn mut_useragent_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.useragent } // required bytes callback_hash = 5; pub fn clear_callback_hash(&mut self) { self.callback_hash.clear(); } pub fn has_callback_hash(&self) -> bool { self.callback_hash.is_some() } // Param is passed by value, moved pub fn set_callback_hash(&mut self, v: ::std::vec::Vec) { self.callback_hash = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_callback_hash(&mut self) -> &mut ::std::vec::Vec { if self.callback_hash.is_none() { self.callback_hash.set_default(); } self.callback_hash.as_mut().unwrap() } // Take field pub fn take_callback_hash(&mut self) -> ::std::vec::Vec { self.callback_hash.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_callback_hash(&self) -> &[u8] { match self.callback_hash.as_ref() { Some(v) => &v, None => &[], } } fn get_callback_hash_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.callback_hash } fn mut_callback_hash_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.callback_hash } } impl ::protobuf::Message for LibspotifyAppKey { fn is_initialized(&self) -> bool { if self.version.is_none() { return false; } if self.devkey.is_none() { return false; } if self.signature.is_none() { return false; } if self.useragent.is_none() { return false; } if self.callback_hash.is_none() { return false; } true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { while !is.eof()? { let (field_number, wire_type) = is.read_tag_unpack()?; match field_number { 1 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_uint32()?; self.version = ::std::option::Option::Some(tmp); }, 2 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.devkey)?; }, 3 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.signature)?; }, 4 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.useragent)?; }, 5 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.callback_hash)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(v) = self.version { my_size += ::protobuf::rt::value_size(1, v, ::protobuf::wire_format::WireTypeVarint); } if let Some(ref v) = self.devkey.as_ref() { my_size += ::protobuf::rt::bytes_size(2, &v); } if let Some(ref v) = self.signature.as_ref() { my_size += ::protobuf::rt::bytes_size(3, &v); } if let Some(ref v) = self.useragent.as_ref() { my_size += ::protobuf::rt::string_size(4, &v); } if let Some(ref v) = self.callback_hash.as_ref() { my_size += ::protobuf::rt::bytes_size(5, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(v) = self.version { os.write_uint32(1, v)?; } if let Some(ref v) = self.devkey.as_ref() { os.write_bytes(2, &v)?; } if let Some(ref v) = self.signature.as_ref() { os.write_bytes(3, &v)?; } if let Some(ref v) = self.useragent.as_ref() { os.write_string(4, &v)?; } if let Some(ref v) = self.callback_hash.as_ref() { os.write_bytes(5, &v)?; } os.write_unknown_fields(self.get_unknown_fields())?; ::std::result::Result::Ok(()) } fn get_cached_size(&self) -> u32 { self.cached_size.get() } fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { &self.unknown_fields } fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { &mut self.unknown_fields } fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for LibspotifyAppKey { fn new() -> LibspotifyAppKey { LibspotifyAppKey::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeUint32>( "version", LibspotifyAppKey::get_version_for_reflect, LibspotifyAppKey::mut_version_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "devkey", LibspotifyAppKey::get_devkey_for_reflect, LibspotifyAppKey::mut_devkey_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "signature", LibspotifyAppKey::get_signature_for_reflect, LibspotifyAppKey::mut_signature_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "useragent", LibspotifyAppKey::get_useragent_for_reflect, LibspotifyAppKey::mut_useragent_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "callback_hash", LibspotifyAppKey::get_callback_hash_for_reflect, LibspotifyAppKey::mut_callback_hash_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "LibspotifyAppKey", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for LibspotifyAppKey { fn clear(&mut self) { self.clear_version(); self.clear_devkey(); self.clear_signature(); self.clear_useragent(); self.clear_callback_hash(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for LibspotifyAppKey { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for LibspotifyAppKey { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct ClientInfo { // message fields limited: ::std::option::Option, fb: ::protobuf::SingularPtrField, language: ::protobuf::SingularField<::std::string::String>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for ClientInfo {} impl ClientInfo { pub fn new() -> ClientInfo { ::std::default::Default::default() } pub fn default_instance() -> &'static ClientInfo { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ClientInfo, }; unsafe { instance.get(ClientInfo::new) } } // optional bool limited = 1; pub fn clear_limited(&mut self) { self.limited = ::std::option::Option::None; } pub fn has_limited(&self) -> bool { self.limited.is_some() } // Param is passed by value, moved pub fn set_limited(&mut self, v: bool) { self.limited = ::std::option::Option::Some(v); } pub fn get_limited(&self) -> bool { self.limited.unwrap_or(false) } fn get_limited_for_reflect(&self) -> &::std::option::Option { &self.limited } fn mut_limited_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.limited } // optional .ClientInfoFacebook fb = 2; pub fn clear_fb(&mut self) { self.fb.clear(); } pub fn has_fb(&self) -> bool { self.fb.is_some() } // Param is passed by value, moved pub fn set_fb(&mut self, v: ClientInfoFacebook) { self.fb = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_fb(&mut self) -> &mut ClientInfoFacebook { if self.fb.is_none() { self.fb.set_default(); } self.fb.as_mut().unwrap() } // Take field pub fn take_fb(&mut self) -> ClientInfoFacebook { self.fb.take().unwrap_or_else(|| ClientInfoFacebook::new()) } pub fn get_fb(&self) -> &ClientInfoFacebook { self.fb.as_ref().unwrap_or_else(|| ClientInfoFacebook::default_instance()) } fn get_fb_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.fb } fn mut_fb_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.fb } // optional string language = 3; pub fn clear_language(&mut self) { self.language.clear(); } pub fn has_language(&self) -> bool { self.language.is_some() } // Param is passed by value, moved pub fn set_language(&mut self, v: ::std::string::String) { self.language = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_language(&mut self) -> &mut ::std::string::String { if self.language.is_none() { self.language.set_default(); } self.language.as_mut().unwrap() } // Take field pub fn take_language(&mut self) -> ::std::string::String { self.language.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_language(&self) -> &str { match self.language.as_ref() { Some(v) => &v, None => "", } } fn get_language_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.language } fn mut_language_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.language } } impl ::protobuf::Message for ClientInfo { fn is_initialized(&self) -> bool { for v in &self.fb { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { while !is.eof()? { let (field_number, wire_type) = is.read_tag_unpack()?; match field_number { 1 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_bool()?; self.limited = ::std::option::Option::Some(tmp); }, 2 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fb)?; }, 3 => { ::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(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(v) = self.limited { my_size += 2; } if let Some(ref v) = self.fb.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.language.as_ref() { my_size += ::protobuf::rt::string_size(3, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(v) = self.limited { os.write_bool(1, v)?; } if let Some(ref v) = self.fb.as_ref() { os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.language.as_ref() { os.write_string(3, &v)?; } os.write_unknown_fields(self.get_unknown_fields())?; ::std::result::Result::Ok(()) } fn get_cached_size(&self) -> u32 { self.cached_size.get() } fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { &self.unknown_fields } fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { &mut self.unknown_fields } fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for ClientInfo { fn new() -> ClientInfo { ClientInfo::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeBool>( "limited", ClientInfo::get_limited_for_reflect, ClientInfo::mut_limited_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "fb", ClientInfo::get_fb_for_reflect, ClientInfo::mut_fb_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "language", ClientInfo::get_language_for_reflect, ClientInfo::mut_language_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "ClientInfo", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for ClientInfo { fn clear(&mut self) { self.clear_limited(); self.clear_fb(); self.clear_language(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for ClientInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for ClientInfo { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct ClientInfoFacebook { // message fields machine_id: ::protobuf::SingularField<::std::string::String>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for ClientInfoFacebook {} impl ClientInfoFacebook { pub fn new() -> ClientInfoFacebook { ::std::default::Default::default() } pub fn default_instance() -> &'static ClientInfoFacebook { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ClientInfoFacebook, }; unsafe { instance.get(ClientInfoFacebook::new) } } // optional string machine_id = 1; pub fn clear_machine_id(&mut self) { self.machine_id.clear(); } pub fn has_machine_id(&self) -> bool { self.machine_id.is_some() } // Param is passed by value, moved pub fn set_machine_id(&mut self, v: ::std::string::String) { self.machine_id = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_machine_id(&mut self) -> &mut ::std::string::String { if self.machine_id.is_none() { self.machine_id.set_default(); } self.machine_id.as_mut().unwrap() } // Take field pub fn take_machine_id(&mut self) -> ::std::string::String { self.machine_id.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_machine_id(&self) -> &str { match self.machine_id.as_ref() { Some(v) => &v, None => "", } } fn get_machine_id_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.machine_id } fn mut_machine_id_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.machine_id } } impl ::protobuf::Message for ClientInfoFacebook { 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.machine_id)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.machine_id.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.machine_id.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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for ClientInfoFacebook { fn new() -> ClientInfoFacebook { ClientInfoFacebook::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "machine_id", ClientInfoFacebook::get_machine_id_for_reflect, ClientInfoFacebook::mut_machine_id_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "ClientInfoFacebook", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for ClientInfoFacebook { fn clear(&mut self) { self.clear_machine_id(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for ClientInfoFacebook { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for ClientInfoFacebook { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct APWelcome { // message fields canonical_username: ::protobuf::SingularField<::std::string::String>, account_type_logged_in: ::std::option::Option, credentials_type_logged_in: ::std::option::Option, reusable_auth_credentials_type: ::std::option::Option, reusable_auth_credentials: ::protobuf::SingularField<::std::vec::Vec>, lfs_secret: ::protobuf::SingularField<::std::vec::Vec>, account_info: ::protobuf::SingularPtrField, fb: ::protobuf::SingularPtrField, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for APWelcome {} impl APWelcome { pub fn new() -> APWelcome { ::std::default::Default::default() } pub fn default_instance() -> &'static APWelcome { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const APWelcome, }; unsafe { instance.get(APWelcome::new) } } // required string canonical_username = 10; pub fn clear_canonical_username(&mut self) { self.canonical_username.clear(); } pub fn has_canonical_username(&self) -> bool { self.canonical_username.is_some() } // Param is passed by value, moved pub fn set_canonical_username(&mut self, v: ::std::string::String) { self.canonical_username = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_canonical_username(&mut self) -> &mut ::std::string::String { if self.canonical_username.is_none() { self.canonical_username.set_default(); } self.canonical_username.as_mut().unwrap() } // Take field pub fn take_canonical_username(&mut self) -> ::std::string::String { self.canonical_username.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_canonical_username(&self) -> &str { match self.canonical_username.as_ref() { Some(v) => &v, None => "", } } fn get_canonical_username_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.canonical_username } fn mut_canonical_username_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.canonical_username } // required .AccountType account_type_logged_in = 20; pub fn clear_account_type_logged_in(&mut self) { self.account_type_logged_in = ::std::option::Option::None; } pub fn has_account_type_logged_in(&self) -> bool { self.account_type_logged_in.is_some() } // Param is passed by value, moved pub fn set_account_type_logged_in(&mut self, v: AccountType) { self.account_type_logged_in = ::std::option::Option::Some(v); } pub fn get_account_type_logged_in(&self) -> AccountType { self.account_type_logged_in.unwrap_or(AccountType::Spotify) } fn get_account_type_logged_in_for_reflect(&self) -> &::std::option::Option { &self.account_type_logged_in } fn mut_account_type_logged_in_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.account_type_logged_in } // required .AccountType credentials_type_logged_in = 25; pub fn clear_credentials_type_logged_in(&mut self) { self.credentials_type_logged_in = ::std::option::Option::None; } pub fn has_credentials_type_logged_in(&self) -> bool { self.credentials_type_logged_in.is_some() } // Param is passed by value, moved pub fn set_credentials_type_logged_in(&mut self, v: AccountType) { self.credentials_type_logged_in = ::std::option::Option::Some(v); } pub fn get_credentials_type_logged_in(&self) -> AccountType { self.credentials_type_logged_in.unwrap_or(AccountType::Spotify) } fn get_credentials_type_logged_in_for_reflect(&self) -> &::std::option::Option { &self.credentials_type_logged_in } fn mut_credentials_type_logged_in_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.credentials_type_logged_in } // required .AuthenticationType reusable_auth_credentials_type = 30; pub fn clear_reusable_auth_credentials_type(&mut self) { self.reusable_auth_credentials_type = ::std::option::Option::None; } pub fn has_reusable_auth_credentials_type(&self) -> bool { self.reusable_auth_credentials_type.is_some() } // Param is passed by value, moved pub fn set_reusable_auth_credentials_type(&mut self, v: AuthenticationType) { self.reusable_auth_credentials_type = ::std::option::Option::Some(v); } pub fn get_reusable_auth_credentials_type(&self) -> AuthenticationType { self.reusable_auth_credentials_type.unwrap_or(AuthenticationType::AUTHENTICATION_USER_PASS) } fn get_reusable_auth_credentials_type_for_reflect(&self) -> &::std::option::Option { &self.reusable_auth_credentials_type } fn mut_reusable_auth_credentials_type_for_reflect(&mut self) -> &mut ::std::option::Option { &mut self.reusable_auth_credentials_type } // required bytes reusable_auth_credentials = 40; pub fn clear_reusable_auth_credentials(&mut self) { self.reusable_auth_credentials.clear(); } pub fn has_reusable_auth_credentials(&self) -> bool { self.reusable_auth_credentials.is_some() } // Param is passed by value, moved pub fn set_reusable_auth_credentials(&mut self, v: ::std::vec::Vec) { self.reusable_auth_credentials = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_reusable_auth_credentials(&mut self) -> &mut ::std::vec::Vec { if self.reusable_auth_credentials.is_none() { self.reusable_auth_credentials.set_default(); } self.reusable_auth_credentials.as_mut().unwrap() } // Take field pub fn take_reusable_auth_credentials(&mut self) -> ::std::vec::Vec { self.reusable_auth_credentials.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_reusable_auth_credentials(&self) -> &[u8] { match self.reusable_auth_credentials.as_ref() { Some(v) => &v, None => &[], } } fn get_reusable_auth_credentials_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.reusable_auth_credentials } fn mut_reusable_auth_credentials_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.reusable_auth_credentials } // optional bytes lfs_secret = 50; pub fn clear_lfs_secret(&mut self) { self.lfs_secret.clear(); } pub fn has_lfs_secret(&self) -> bool { self.lfs_secret.is_some() } // Param is passed by value, moved pub fn set_lfs_secret(&mut self, v: ::std::vec::Vec) { self.lfs_secret = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_lfs_secret(&mut self) -> &mut ::std::vec::Vec { if self.lfs_secret.is_none() { self.lfs_secret.set_default(); } self.lfs_secret.as_mut().unwrap() } // Take field pub fn take_lfs_secret(&mut self) -> ::std::vec::Vec { self.lfs_secret.take().unwrap_or_else(|| ::std::vec::Vec::new()) } pub fn get_lfs_secret(&self) -> &[u8] { match self.lfs_secret.as_ref() { Some(v) => &v, None => &[], } } fn get_lfs_secret_for_reflect(&self) -> &::protobuf::SingularField<::std::vec::Vec> { &self.lfs_secret } fn mut_lfs_secret_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::vec::Vec> { &mut self.lfs_secret } // optional .AccountInfo account_info = 60; pub fn clear_account_info(&mut self) { self.account_info.clear(); } pub fn has_account_info(&self) -> bool { self.account_info.is_some() } // Param is passed by value, moved pub fn set_account_info(&mut self, v: AccountInfo) { self.account_info = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_account_info(&mut self) -> &mut AccountInfo { if self.account_info.is_none() { self.account_info.set_default(); } self.account_info.as_mut().unwrap() } // Take field pub fn take_account_info(&mut self) -> AccountInfo { self.account_info.take().unwrap_or_else(|| AccountInfo::new()) } pub fn get_account_info(&self) -> &AccountInfo { self.account_info.as_ref().unwrap_or_else(|| AccountInfo::default_instance()) } fn get_account_info_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.account_info } fn mut_account_info_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.account_info } // optional .AccountInfoFacebook fb = 70; pub fn clear_fb(&mut self) { self.fb.clear(); } pub fn has_fb(&self) -> bool { self.fb.is_some() } // Param is passed by value, moved pub fn set_fb(&mut self, v: AccountInfoFacebook) { self.fb = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_fb(&mut self) -> &mut AccountInfoFacebook { if self.fb.is_none() { self.fb.set_default(); } self.fb.as_mut().unwrap() } // Take field pub fn take_fb(&mut self) -> AccountInfoFacebook { self.fb.take().unwrap_or_else(|| AccountInfoFacebook::new()) } pub fn get_fb(&self) -> &AccountInfoFacebook { self.fb.as_ref().unwrap_or_else(|| AccountInfoFacebook::default_instance()) } fn get_fb_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.fb } fn mut_fb_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.fb } } impl ::protobuf::Message for APWelcome { fn is_initialized(&self) -> bool { if self.canonical_username.is_none() { return false; } if self.account_type_logged_in.is_none() { return false; } if self.credentials_type_logged_in.is_none() { return false; } if self.reusable_auth_credentials_type.is_none() { return false; } if self.reusable_auth_credentials.is_none() { return false; } for v in &self.account_info { if !v.is_initialized() { return false; } }; for v in &self.fb { 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 { 10 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.canonical_username)?; }, 20 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.account_type_logged_in = ::std::option::Option::Some(tmp); }, 25 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.credentials_type_logged_in = ::std::option::Option::Some(tmp); }, 30 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); } let tmp = is.read_enum()?; self.reusable_auth_credentials_type = ::std::option::Option::Some(tmp); }, 40 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.reusable_auth_credentials)?; }, 50 => { ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.lfs_secret)?; }, 60 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.account_info)?; }, 70 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.fb)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.canonical_username.as_ref() { my_size += ::protobuf::rt::string_size(10, &v); } if let Some(v) = self.account_type_logged_in { my_size += ::protobuf::rt::enum_size(20, v); } if let Some(v) = self.credentials_type_logged_in { my_size += ::protobuf::rt::enum_size(25, v); } if let Some(v) = self.reusable_auth_credentials_type { my_size += ::protobuf::rt::enum_size(30, v); } if let Some(ref v) = self.reusable_auth_credentials.as_ref() { my_size += ::protobuf::rt::bytes_size(40, &v); } if let Some(ref v) = self.lfs_secret.as_ref() { my_size += ::protobuf::rt::bytes_size(50, &v); } if let Some(ref v) = self.account_info.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.fb.as_ref() { let len = v.compute_size(); my_size += 2 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(ref v) = self.canonical_username.as_ref() { os.write_string(10, &v)?; } if let Some(v) = self.account_type_logged_in { os.write_enum(20, v.value())?; } if let Some(v) = self.credentials_type_logged_in { os.write_enum(25, v.value())?; } if let Some(v) = self.reusable_auth_credentials_type { os.write_enum(30, v.value())?; } if let Some(ref v) = self.reusable_auth_credentials.as_ref() { os.write_bytes(40, &v)?; } if let Some(ref v) = self.lfs_secret.as_ref() { os.write_bytes(50, &v)?; } if let Some(ref v) = self.account_info.as_ref() { os.write_tag(60, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.fb.as_ref() { os.write_tag(70, ::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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for APWelcome { fn new() -> APWelcome { APWelcome::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "canonical_username", APWelcome::get_canonical_username_for_reflect, APWelcome::mut_canonical_username_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "account_type_logged_in", APWelcome::get_account_type_logged_in_for_reflect, APWelcome::mut_account_type_logged_in_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "credentials_type_logged_in", APWelcome::get_credentials_type_logged_in_for_reflect, APWelcome::mut_credentials_type_logged_in_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_option_accessor::<_, ::protobuf::types::ProtobufTypeEnum>( "reusable_auth_credentials_type", APWelcome::get_reusable_auth_credentials_type_for_reflect, APWelcome::mut_reusable_auth_credentials_type_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "reusable_auth_credentials", APWelcome::get_reusable_auth_credentials_for_reflect, APWelcome::mut_reusable_auth_credentials_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>( "lfs_secret", APWelcome::get_lfs_secret_for_reflect, APWelcome::mut_lfs_secret_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "account_info", APWelcome::get_account_info_for_reflect, APWelcome::mut_account_info_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "fb", APWelcome::get_fb_for_reflect, APWelcome::mut_fb_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "APWelcome", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for APWelcome { fn clear(&mut self) { self.clear_canonical_username(); self.clear_account_type_logged_in(); self.clear_credentials_type_logged_in(); self.clear_reusable_auth_credentials_type(); self.clear_reusable_auth_credentials(); self.clear_lfs_secret(); self.clear_account_info(); self.clear_fb(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for APWelcome { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for APWelcome { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct AccountInfo { // message fields spotify: ::protobuf::SingularPtrField, facebook: ::protobuf::SingularPtrField, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for AccountInfo {} impl AccountInfo { pub fn new() -> AccountInfo { ::std::default::Default::default() } pub fn default_instance() -> &'static AccountInfo { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const AccountInfo, }; unsafe { instance.get(AccountInfo::new) } } // optional .AccountInfoSpotify spotify = 1; pub fn clear_spotify(&mut self) { self.spotify.clear(); } pub fn has_spotify(&self) -> bool { self.spotify.is_some() } // Param is passed by value, moved pub fn set_spotify(&mut self, v: AccountInfoSpotify) { self.spotify = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_spotify(&mut self) -> &mut AccountInfoSpotify { if self.spotify.is_none() { self.spotify.set_default(); } self.spotify.as_mut().unwrap() } // Take field pub fn take_spotify(&mut self) -> AccountInfoSpotify { self.spotify.take().unwrap_or_else(|| AccountInfoSpotify::new()) } pub fn get_spotify(&self) -> &AccountInfoSpotify { self.spotify.as_ref().unwrap_or_else(|| AccountInfoSpotify::default_instance()) } fn get_spotify_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.spotify } fn mut_spotify_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.spotify } // optional .AccountInfoFacebook facebook = 2; pub fn clear_facebook(&mut self) { self.facebook.clear(); } pub fn has_facebook(&self) -> bool { self.facebook.is_some() } // Param is passed by value, moved pub fn set_facebook(&mut self, v: AccountInfoFacebook) { self.facebook = ::protobuf::SingularPtrField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_facebook(&mut self) -> &mut AccountInfoFacebook { if self.facebook.is_none() { self.facebook.set_default(); } self.facebook.as_mut().unwrap() } // Take field pub fn take_facebook(&mut self) -> AccountInfoFacebook { self.facebook.take().unwrap_or_else(|| AccountInfoFacebook::new()) } pub fn get_facebook(&self) -> &AccountInfoFacebook { self.facebook.as_ref().unwrap_or_else(|| AccountInfoFacebook::default_instance()) } fn get_facebook_for_reflect(&self) -> &::protobuf::SingularPtrField { &self.facebook } fn mut_facebook_for_reflect(&mut self) -> &mut ::protobuf::SingularPtrField { &mut self.facebook } } impl ::protobuf::Message for AccountInfo { fn is_initialized(&self) -> bool { for v in &self.spotify { if !v.is_initialized() { return false; } }; for v in &self.facebook { if !v.is_initialized() { return false; } }; true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { while !is.eof()? { let (field_number, wire_type) = is.read_tag_unpack()?; match field_number { 1 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.spotify)?; }, 2 => { ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.facebook)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.spotify.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } if let Some(ref v) = self.facebook.as_ref() { let len = v.compute_size(); my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(ref v) = self.spotify.as_ref() { os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } if let Some(ref v) = self.facebook.as_ref() { os.write_tag(2, ::protobuf::wire_format::WireTypeLengthDelimited)?; os.write_raw_varint32(v.get_cached_size())?; v.write_to_with_cached_sizes(os)?; } os.write_unknown_fields(self.get_unknown_fields())?; ::std::result::Result::Ok(()) } fn get_cached_size(&self) -> u32 { self.cached_size.get() } fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { &self.unknown_fields } fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { &mut self.unknown_fields } fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for AccountInfo { fn new() -> AccountInfo { AccountInfo::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "spotify", AccountInfo::get_spotify_for_reflect, AccountInfo::mut_spotify_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_ptr_field_accessor::<_, ::protobuf::types::ProtobufTypeMessage>( "facebook", AccountInfo::get_facebook_for_reflect, AccountInfo::mut_facebook_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "AccountInfo", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for AccountInfo { fn clear(&mut self) { self.clear_spotify(); self.clear_facebook(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for AccountInfo { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for AccountInfo { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct AccountInfoSpotify { // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for AccountInfoSpotify {} impl AccountInfoSpotify { pub fn new() -> AccountInfoSpotify { ::std::default::Default::default() } pub fn default_instance() -> &'static AccountInfoSpotify { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const AccountInfoSpotify, }; unsafe { instance.get(AccountInfoSpotify::new) } } } impl ::protobuf::Message for AccountInfoSpotify { 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(()) } // Compute sizes of nested messages #[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) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for AccountInfoSpotify { fn new() -> AccountInfoSpotify { AccountInfoSpotify::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let fields = ::std::vec::Vec::new(); ::protobuf::reflect::MessageDescriptor::new::( "AccountInfoSpotify", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for AccountInfoSpotify { fn clear(&mut self) { self.unknown_fields.clear(); } } impl ::std::fmt::Debug for AccountInfoSpotify { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for AccountInfoSpotify { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(PartialEq,Clone,Default)] pub struct AccountInfoFacebook { // message fields access_token: ::protobuf::SingularField<::std::string::String>, machine_id: ::protobuf::SingularField<::std::string::String>, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::protobuf::CachedSize, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for AccountInfoFacebook {} impl AccountInfoFacebook { pub fn new() -> AccountInfoFacebook { ::std::default::Default::default() } pub fn default_instance() -> &'static AccountInfoFacebook { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const AccountInfoFacebook, }; unsafe { instance.get(AccountInfoFacebook::new) } } // optional string access_token = 1; pub fn clear_access_token(&mut self) { self.access_token.clear(); } pub fn has_access_token(&self) -> bool { self.access_token.is_some() } // Param is passed by value, moved pub fn set_access_token(&mut self, v: ::std::string::String) { self.access_token = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_access_token(&mut self) -> &mut ::std::string::String { if self.access_token.is_none() { self.access_token.set_default(); } self.access_token.as_mut().unwrap() } // Take field pub fn take_access_token(&mut self) -> ::std::string::String { self.access_token.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_access_token(&self) -> &str { match self.access_token.as_ref() { Some(v) => &v, None => "", } } fn get_access_token_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.access_token } fn mut_access_token_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.access_token } // optional string machine_id = 2; pub fn clear_machine_id(&mut self) { self.machine_id.clear(); } pub fn has_machine_id(&self) -> bool { self.machine_id.is_some() } // Param is passed by value, moved pub fn set_machine_id(&mut self, v: ::std::string::String) { self.machine_id = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_machine_id(&mut self) -> &mut ::std::string::String { if self.machine_id.is_none() { self.machine_id.set_default(); } self.machine_id.as_mut().unwrap() } // Take field pub fn take_machine_id(&mut self) -> ::std::string::String { self.machine_id.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_machine_id(&self) -> &str { match self.machine_id.as_ref() { Some(v) => &v, None => "", } } fn get_machine_id_for_reflect(&self) -> &::protobuf::SingularField<::std::string::String> { &self.machine_id } fn mut_machine_id_for_reflect(&mut self) -> &mut ::protobuf::SingularField<::std::string::String> { &mut self.machine_id } } impl ::protobuf::Message for AccountInfoFacebook { 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.access_token)?; }, 2 => { ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.machine_id)?; }, _ => { ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; }, }; } ::std::result::Result::Ok(()) } // Compute sizes of nested messages #[allow(unused_variables)] fn compute_size(&self) -> u32 { let mut my_size = 0; if let Some(ref v) = self.access_token.as_ref() { my_size += ::protobuf::rt::string_size(1, &v); } if let Some(ref v) = self.machine_id.as_ref() { my_size += ::protobuf::rt::string_size(2, &v); } my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(ref v) = self.access_token.as_ref() { os.write_string(1, &v)?; } if let Some(ref v) = self.machine_id.as_ref() { os.write_string(2, &v)?; } os.write_unknown_fields(self.get_unknown_fields())?; ::std::result::Result::Ok(()) } fn get_cached_size(&self) -> u32 { self.cached_size.get() } fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { &self.unknown_fields } fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { &mut self.unknown_fields } fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } fn as_any_mut(&mut self) -> &mut ::std::any::Any { self as &mut ::std::any::Any } fn into_any(self: Box) -> ::std::boxed::Box<::std::any::Any> { self } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for AccountInfoFacebook { fn new() -> AccountInfoFacebook { AccountInfoFacebook::new() } fn descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::MessageDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::MessageDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::MessageDescriptor, }; unsafe { descriptor.get(|| { let mut fields = ::std::vec::Vec::new(); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "access_token", AccountInfoFacebook::get_access_token_for_reflect, AccountInfoFacebook::mut_access_token_for_reflect, )); fields.push(::protobuf::reflect::accessor::make_singular_field_accessor::<_, ::protobuf::types::ProtobufTypeString>( "machine_id", AccountInfoFacebook::get_machine_id_for_reflect, AccountInfoFacebook::mut_machine_id_for_reflect, )); ::protobuf::reflect::MessageDescriptor::new::( "AccountInfoFacebook", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for AccountInfoFacebook { fn clear(&mut self) { self.clear_access_token(); self.clear_machine_id(); self.unknown_fields.clear(); } } impl ::std::fmt::Debug for AccountInfoFacebook { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } impl ::protobuf::reflect::ProtobufValue for AccountInfoFacebook { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Message(self) } } #[derive(Clone,PartialEq,Eq,Debug,Hash)] pub enum AuthenticationType { AUTHENTICATION_USER_PASS = 0, AUTHENTICATION_STORED_SPOTIFY_CREDENTIALS = 1, AUTHENTICATION_STORED_FACEBOOK_CREDENTIALS = 2, AUTHENTICATION_SPOTIFY_TOKEN = 3, AUTHENTICATION_FACEBOOK_TOKEN = 4, } impl ::protobuf::ProtobufEnum for AuthenticationType { fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 0 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_USER_PASS), 1 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_STORED_SPOTIFY_CREDENTIALS), 2 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_STORED_FACEBOOK_CREDENTIALS), 3 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_SPOTIFY_TOKEN), 4 => ::std::option::Option::Some(AuthenticationType::AUTHENTICATION_FACEBOOK_TOKEN), _ => ::std::option::Option::None } } fn values() -> &'static [Self] { static values: &'static [AuthenticationType] = &[ AuthenticationType::AUTHENTICATION_USER_PASS, AuthenticationType::AUTHENTICATION_STORED_SPOTIFY_CREDENTIALS, AuthenticationType::AUTHENTICATION_STORED_FACEBOOK_CREDENTIALS, AuthenticationType::AUTHENTICATION_SPOTIFY_TOKEN, AuthenticationType::AUTHENTICATION_FACEBOOK_TOKEN, ]; values } fn enum_descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::EnumDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, }; unsafe { descriptor.get(|| { ::protobuf::reflect::EnumDescriptor::new("AuthenticationType", file_descriptor_proto()) }) } } } impl ::std::marker::Copy for AuthenticationType { } impl ::protobuf::reflect::ProtobufValue for AuthenticationType { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) } } #[derive(Clone,PartialEq,Eq,Debug,Hash)] pub enum AccountCreation { ACCOUNT_CREATION_ALWAYS_PROMPT = 1, ACCOUNT_CREATION_ALWAYS_CREATE = 3, } impl ::protobuf::ProtobufEnum for AccountCreation { fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 1 => ::std::option::Option::Some(AccountCreation::ACCOUNT_CREATION_ALWAYS_PROMPT), 3 => ::std::option::Option::Some(AccountCreation::ACCOUNT_CREATION_ALWAYS_CREATE), _ => ::std::option::Option::None } } fn values() -> &'static [Self] { static values: &'static [AccountCreation] = &[ AccountCreation::ACCOUNT_CREATION_ALWAYS_PROMPT, AccountCreation::ACCOUNT_CREATION_ALWAYS_CREATE, ]; values } fn enum_descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::EnumDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, }; unsafe { descriptor.get(|| { ::protobuf::reflect::EnumDescriptor::new("AccountCreation", file_descriptor_proto()) }) } } } impl ::std::marker::Copy for AccountCreation { } impl ::protobuf::reflect::ProtobufValue for AccountCreation { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) } } #[derive(Clone,PartialEq,Eq,Debug,Hash)] pub enum CpuFamily { CPU_UNKNOWN = 0, CPU_X86 = 1, CPU_X86_64 = 2, CPU_PPC = 3, CPU_PPC_64 = 4, CPU_ARM = 5, CPU_IA64 = 6, CPU_SH = 7, CPU_MIPS = 8, CPU_BLACKFIN = 9, } impl ::protobuf::ProtobufEnum for CpuFamily { fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 0 => ::std::option::Option::Some(CpuFamily::CPU_UNKNOWN), 1 => ::std::option::Option::Some(CpuFamily::CPU_X86), 2 => ::std::option::Option::Some(CpuFamily::CPU_X86_64), 3 => ::std::option::Option::Some(CpuFamily::CPU_PPC), 4 => ::std::option::Option::Some(CpuFamily::CPU_PPC_64), 5 => ::std::option::Option::Some(CpuFamily::CPU_ARM), 6 => ::std::option::Option::Some(CpuFamily::CPU_IA64), 7 => ::std::option::Option::Some(CpuFamily::CPU_SH), 8 => ::std::option::Option::Some(CpuFamily::CPU_MIPS), 9 => ::std::option::Option::Some(CpuFamily::CPU_BLACKFIN), _ => ::std::option::Option::None } } fn values() -> &'static [Self] { static values: &'static [CpuFamily] = &[ CpuFamily::CPU_UNKNOWN, CpuFamily::CPU_X86, CpuFamily::CPU_X86_64, CpuFamily::CPU_PPC, CpuFamily::CPU_PPC_64, CpuFamily::CPU_ARM, CpuFamily::CPU_IA64, CpuFamily::CPU_SH, CpuFamily::CPU_MIPS, CpuFamily::CPU_BLACKFIN, ]; values } fn enum_descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::EnumDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, }; unsafe { descriptor.get(|| { ::protobuf::reflect::EnumDescriptor::new("CpuFamily", file_descriptor_proto()) }) } } } impl ::std::marker::Copy for CpuFamily { } impl ::protobuf::reflect::ProtobufValue for CpuFamily { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) } } #[derive(Clone,PartialEq,Eq,Debug,Hash)] pub enum Brand { BRAND_UNBRANDED = 0, BRAND_INQ = 1, BRAND_HTC = 2, BRAND_NOKIA = 3, } impl ::protobuf::ProtobufEnum for Brand { fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 0 => ::std::option::Option::Some(Brand::BRAND_UNBRANDED), 1 => ::std::option::Option::Some(Brand::BRAND_INQ), 2 => ::std::option::Option::Some(Brand::BRAND_HTC), 3 => ::std::option::Option::Some(Brand::BRAND_NOKIA), _ => ::std::option::Option::None } } fn values() -> &'static [Self] { static values: &'static [Brand] = &[ Brand::BRAND_UNBRANDED, Brand::BRAND_INQ, Brand::BRAND_HTC, Brand::BRAND_NOKIA, ]; values } fn enum_descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::EnumDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, }; unsafe { descriptor.get(|| { ::protobuf::reflect::EnumDescriptor::new("Brand", file_descriptor_proto()) }) } } } impl ::std::marker::Copy for Brand { } impl ::protobuf::reflect::ProtobufValue for Brand { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) } } #[derive(Clone,PartialEq,Eq,Debug,Hash)] pub enum Os { OS_UNKNOWN = 0, OS_WINDOWS = 1, OS_OSX = 2, OS_IPHONE = 3, OS_S60 = 4, OS_LINUX = 5, OS_WINDOWS_CE = 6, OS_ANDROID = 7, OS_PALM = 8, OS_FREEBSD = 9, OS_BLACKBERRY = 10, OS_SONOS = 11, OS_LOGITECH = 12, OS_WP7 = 13, OS_ONKYO = 14, OS_PHILIPS = 15, OS_WD = 16, OS_VOLVO = 17, OS_TIVO = 18, OS_AWOX = 19, OS_MEEGO = 20, OS_QNXNTO = 21, OS_BCO = 22, } impl ::protobuf::ProtobufEnum for Os { fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 0 => ::std::option::Option::Some(Os::OS_UNKNOWN), 1 => ::std::option::Option::Some(Os::OS_WINDOWS), 2 => ::std::option::Option::Some(Os::OS_OSX), 3 => ::std::option::Option::Some(Os::OS_IPHONE), 4 => ::std::option::Option::Some(Os::OS_S60), 5 => ::std::option::Option::Some(Os::OS_LINUX), 6 => ::std::option::Option::Some(Os::OS_WINDOWS_CE), 7 => ::std::option::Option::Some(Os::OS_ANDROID), 8 => ::std::option::Option::Some(Os::OS_PALM), 9 => ::std::option::Option::Some(Os::OS_FREEBSD), 10 => ::std::option::Option::Some(Os::OS_BLACKBERRY), 11 => ::std::option::Option::Some(Os::OS_SONOS), 12 => ::std::option::Option::Some(Os::OS_LOGITECH), 13 => ::std::option::Option::Some(Os::OS_WP7), 14 => ::std::option::Option::Some(Os::OS_ONKYO), 15 => ::std::option::Option::Some(Os::OS_PHILIPS), 16 => ::std::option::Option::Some(Os::OS_WD), 17 => ::std::option::Option::Some(Os::OS_VOLVO), 18 => ::std::option::Option::Some(Os::OS_TIVO), 19 => ::std::option::Option::Some(Os::OS_AWOX), 20 => ::std::option::Option::Some(Os::OS_MEEGO), 21 => ::std::option::Option::Some(Os::OS_QNXNTO), 22 => ::std::option::Option::Some(Os::OS_BCO), _ => ::std::option::Option::None } } fn values() -> &'static [Self] { static values: &'static [Os] = &[ Os::OS_UNKNOWN, Os::OS_WINDOWS, Os::OS_OSX, Os::OS_IPHONE, Os::OS_S60, Os::OS_LINUX, Os::OS_WINDOWS_CE, Os::OS_ANDROID, Os::OS_PALM, Os::OS_FREEBSD, Os::OS_BLACKBERRY, Os::OS_SONOS, Os::OS_LOGITECH, Os::OS_WP7, Os::OS_ONKYO, Os::OS_PHILIPS, Os::OS_WD, Os::OS_VOLVO, Os::OS_TIVO, Os::OS_AWOX, Os::OS_MEEGO, Os::OS_QNXNTO, Os::OS_BCO, ]; values } fn enum_descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::EnumDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, }; unsafe { descriptor.get(|| { ::protobuf::reflect::EnumDescriptor::new("Os", file_descriptor_proto()) }) } } } impl ::std::marker::Copy for Os { } impl ::protobuf::reflect::ProtobufValue for Os { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) } } #[derive(Clone,PartialEq,Eq,Debug,Hash)] pub enum AccountType { Spotify = 0, Facebook = 1, } impl ::protobuf::ProtobufEnum for AccountType { fn value(&self) -> i32 { *self as i32 } fn from_i32(value: i32) -> ::std::option::Option { match value { 0 => ::std::option::Option::Some(AccountType::Spotify), 1 => ::std::option::Option::Some(AccountType::Facebook), _ => ::std::option::Option::None } } fn values() -> &'static [Self] { static values: &'static [AccountType] = &[ AccountType::Spotify, AccountType::Facebook, ]; values } fn enum_descriptor_static(_: ::std::option::Option) -> &'static ::protobuf::reflect::EnumDescriptor { static mut descriptor: ::protobuf::lazy::Lazy<::protobuf::reflect::EnumDescriptor> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::reflect::EnumDescriptor, }; unsafe { descriptor.get(|| { ::protobuf::reflect::EnumDescriptor::new("AccountType", file_descriptor_proto()) }) } } } impl ::std::marker::Copy for AccountType { } impl ::protobuf::reflect::ProtobufValue for AccountType { fn as_ref(&self) -> ::protobuf::reflect::ProtobufValueRef { ::protobuf::reflect::ProtobufValueRef::Enum(self.descriptor()) } } static file_descriptor_proto_data: &'static [u8] = b"\ \n\x14authentication.proto\"\xec\x03\n\x17ClientResponseEncrypted\x12>\n\ \x11login_credentials\x18\n\x20\x02(\x0b2\x11.LoginCredentialsR\x10login\ Credentials\x12;\n\x10account_creation\x18\x14\x20\x01(\x0e2\x10.Account\ CreationR\x0faccountCreation\x12L\n\x14fingerprint_response\x18\x1e\x20\ \x01(\x0b2\x19.FingerprintResponseUnionR\x13fingerprintResponse\x121\n\ \x0bpeer_ticket\x18(\x20\x01(\x0b2\x10.PeerTicketUnionR\npeerTicket\x12,\ \n\x0bsystem_info\x182\x20\x02(\x0b2\x0b.SystemInfoR\nsystemInfo\x12%\n\ \x0eplatform_model\x18<\x20\x01(\tR\rplatformModel\x12%\n\x0eversion_str\ ing\x18F\x20\x01(\tR\rversionString\x12)\n\x06appkey\x18P\x20\x01(\x0b2\ \x11.LibspotifyAppKeyR\x06appkey\x12,\n\x0bclient_info\x18Z\x20\x01(\x0b\ 2\x0b.ClientInfoR\nclientInfo\"r\n\x10LoginCredentials\x12\x1a\n\x08user\ name\x18\n\x20\x01(\tR\x08username\x12%\n\x03typ\x18\x14\x20\x02(\x0e2\ \x13.AuthenticationTypeR\x03typ\x12\x1b\n\tauth_data\x18\x1e\x20\x01(\ \x0cR\x08authData\"\x8c\x01\n\x18FingerprintResponseUnion\x12/\n\x05grai\ n\x18\n\x20\x01(\x0b2\x19.FingerprintGrainResponseR\x05grain\x12?\n\x0bh\ mac_ripemd\x18\x14\x20\x01(\x0b2\x1e.FingerprintHmacRipemdResponseR\nhma\ cRipemd\"?\n\x18FingerprintGrainResponse\x12#\n\rencrypted_key\x18\n\x20\ \x02(\x0cR\x0cencryptedKey\"3\n\x1dFingerprintHmacRipemdResponse\x12\x12\ \n\x04hmac\x18\n\x20\x02(\x0cR\x04hmac\"u\n\x0fPeerTicketUnion\x123\n\np\ ublic_key\x18\n\x20\x01(\x0b2\x14.PeerTicketPublicKeyR\tpublicKey\x12-\n\ \nold_ticket\x18\x14\x20\x01(\x0b2\x0e.PeerTicketOldR\toldTicket\"4\n\ \x13PeerTicketPublicKey\x12\x1d\n\npublic_key\x18\n\x20\x02(\x0cR\tpubli\ cKey\"d\n\rPeerTicketOld\x12\x1f\n\x0bpeer_ticket\x18\n\x20\x02(\x0cR\np\ eerTicket\x122\n\x15peer_ticket_signature\x18\x14\x20\x02(\x0cR\x13peerT\ icketSignature\"\xd4\x02\n\nSystemInfo\x12)\n\ncpu_family\x18\n\x20\x02(\ \x0e2\n.CpuFamilyR\tcpuFamily\x12\x1f\n\x0bcpu_subtype\x18\x14\x20\x01(\ \rR\ncpuSubtype\x12\x17\n\x07cpu_ext\x18\x1e\x20\x01(\rR\x06cpuExt\x12\ \x1c\n\x05brand\x18(\x20\x01(\x0e2\x06.BrandR\x05brand\x12\x1f\n\x0bbran\ d_flags\x182\x20\x01(\rR\nbrandFlags\x12\x13\n\x02os\x18<\x20\x02(\x0e2\ \x03.OsR\x02os\x12\x1d\n\nos_version\x18F\x20\x01(\rR\tosVersion\x12\x15\ \n\x06os_ext\x18P\x20\x01(\rR\x05osExt\x12:\n\x19system_information_stri\ ng\x18Z\x20\x01(\tR\x17systemInformationString\x12\x1b\n\tdevice_id\x18d\ \x20\x01(\tR\x08deviceId\"\xa5\x01\n\x10LibspotifyAppKey\x12\x18\n\x07ve\ rsion\x18\x01\x20\x02(\rR\x07version\x12\x16\n\x06devkey\x18\x02\x20\x02\ (\x0cR\x06devkey\x12\x1c\n\tsignature\x18\x03\x20\x02(\x0cR\tsignature\ \x12\x1c\n\tuseragent\x18\x04\x20\x02(\tR\tuseragent\x12#\n\rcallback_ha\ sh\x18\x05\x20\x02(\x0cR\x0ccallbackHash\"g\n\nClientInfo\x12\x18\n\x07l\ imited\x18\x01\x20\x01(\x08R\x07limited\x12#\n\x02fb\x18\x02\x20\x01(\ \x0b2\x13.ClientInfoFacebookR\x02fb\x12\x1a\n\x08language\x18\x03\x20\ \x01(\tR\x08language\"3\n\x12ClientInfoFacebook\x12\x1d\n\nmachine_id\ \x18\x01\x20\x01(\tR\tmachineId\"\xd4\x03\n\tAPWelcome\x12-\n\x12canonic\ al_username\x18\n\x20\x02(\tR\x11canonicalUsername\x12A\n\x16account_typ\ e_logged_in\x18\x14\x20\x02(\x0e2\x0c.AccountTypeR\x13accountTypeLoggedI\ n\x12I\n\x1acredentials_type_logged_in\x18\x19\x20\x02(\x0e2\x0c.Account\ TypeR\x17credentialsTypeLoggedIn\x12X\n\x1ereusable_auth_credentials_typ\ e\x18\x1e\x20\x02(\x0e2\x13.AuthenticationTypeR\x1breusableAuthCredentia\ lsType\x12:\n\x19reusable_auth_credentials\x18(\x20\x02(\x0cR\x17reusabl\ eAuthCredentials\x12\x1d\n\nlfs_secret\x182\x20\x01(\x0cR\tlfsSecret\x12\ /\n\x0caccount_info\x18<\x20\x01(\x0b2\x0c.AccountInfoR\x0baccountInfo\ \x12$\n\x02fb\x18F\x20\x01(\x0b2\x14.AccountInfoFacebookR\x02fb\"n\n\x0b\ AccountInfo\x12-\n\x07spotify\x18\x01\x20\x01(\x0b2\x13.AccountInfoSpoti\ fyR\x07spotify\x120\n\x08facebook\x18\x02\x20\x01(\x0b2\x14.AccountInfoF\ acebookR\x08facebook\"\x14\n\x12AccountInfoSpotify\"W\n\x13AccountInfoFa\ cebook\x12!\n\x0caccess_token\x18\x01\x20\x01(\tR\x0baccessToken\x12\x1d\ \n\nmachine_id\x18\x02\x20\x01(\tR\tmachineId*\xd6\x01\n\x12Authenticati\ onType\x12\x1c\n\x18AUTHENTICATION_USER_PASS\x10\0\x12-\n)AUTHENTICATION\ _STORED_SPOTIFY_CREDENTIALS\x10\x01\x12.\n*AUTHENTICATION_STORED_FACEBOO\ K_CREDENTIALS\x10\x02\x12\x20\n\x1cAUTHENTICATION_SPOTIFY_TOKEN\x10\x03\ \x12!\n\x1dAUTHENTICATION_FACEBOOK_TOKEN\x10\x04*Y\n\x0fAccountCreation\ \x12\"\n\x1eACCOUNT_CREATION_ALWAYS_PROMPT\x10\x01\x12\"\n\x1eACCOUNT_CR\ EATION_ALWAYS_CREATE\x10\x03*\x9d\x01\n\tCpuFamily\x12\x0f\n\x0bCPU_UNKN\ OWN\x10\0\x12\x0b\n\x07CPU_X86\x10\x01\x12\x0e\n\nCPU_X86_64\x10\x02\x12\ \x0b\n\x07CPU_PPC\x10\x03\x12\x0e\n\nCPU_PPC_64\x10\x04\x12\x0b\n\x07CPU\ _ARM\x10\x05\x12\x0c\n\x08CPU_IA64\x10\x06\x12\n\n\x06CPU_SH\x10\x07\x12\ \x0c\n\x08CPU_MIPS\x10\x08\x12\x10\n\x0cCPU_BLACKFIN\x10\t*K\n\x05Brand\ \x12\x13\n\x0fBRAND_UNBRANDED\x10\0\x12\r\n\tBRAND_INQ\x10\x01\x12\r\n\t\ BRAND_HTC\x10\x02\x12\x0f\n\x0bBRAND_NOKIA\x10\x03*\xd1\x02\n\x02Os\x12\ \x0e\n\nOS_UNKNOWN\x10\0\x12\x0e\n\nOS_WINDOWS\x10\x01\x12\n\n\x06OS_OSX\ \x10\x02\x12\r\n\tOS_IPHONE\x10\x03\x12\n\n\x06OS_S60\x10\x04\x12\x0c\n\ \x08OS_LINUX\x10\x05\x12\x11\n\rOS_WINDOWS_CE\x10\x06\x12\x0e\n\nOS_ANDR\ OID\x10\x07\x12\x0b\n\x07OS_PALM\x10\x08\x12\x0e\n\nOS_FREEBSD\x10\t\x12\ \x11\n\rOS_BLACKBERRY\x10\n\x12\x0c\n\x08OS_SONOS\x10\x0b\x12\x0f\n\x0bO\ S_LOGITECH\x10\x0c\x12\n\n\x06OS_WP7\x10\r\x12\x0c\n\x08OS_ONKYO\x10\x0e\ \x12\x0e\n\nOS_PHILIPS\x10\x0f\x12\t\n\x05OS_WD\x10\x10\x12\x0c\n\x08OS_\ VOLVO\x10\x11\x12\x0b\n\x07OS_TIVO\x10\x12\x12\x0b\n\x07OS_AWOX\x10\x13\ \x12\x0c\n\x08OS_MEEGO\x10\x14\x12\r\n\tOS_QNXNTO\x10\x15\x12\n\n\x06OS_\ BCO\x10\x16*(\n\x0bAccountType\x12\x0b\n\x07Spotify\x10\0\x12\x0c\n\x08F\ acebook\x10\x01J\xee/\n\x07\x12\x05\0\0\xa4\x01\x01\n\x08\n\x01\x0c\x12\ \x03\0\0\x12\n\n\n\x02\x04\0\x12\x04\x02\0\x0c\x01\n\n\n\x03\x04\0\x01\ \x12\x03\x02\x08\x1f\n\x0b\n\x04\x04\0\x02\0\x12\x03\x03\x046\n\x0c\n\ \x05\x04\0\x02\0\x04\x12\x03\x03\x04\x0c\n\x0c\n\x05\x04\0\x02\0\x06\x12\ \x03\x03\r\x1d\n\x0c\n\x05\x04\0\x02\0\x01\x12\x03\x03\x1e/\n\x0c\n\x05\ \x04\0\x02\0\x03\x12\x03\x0325\n\x0b\n\x04\x04\0\x02\x01\x12\x03\x04\x04\ 5\n\x0c\n\x05\x04\0\x02\x01\x04\x12\x03\x04\x04\x0c\n\x0c\n\x05\x04\0\ \x02\x01\x06\x12\x03\x04\r\x1c\n\x0c\n\x05\x04\0\x02\x01\x01\x12\x03\x04\ \x1d-\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x0404\n\x0b\n\x04\x04\0\x02\ \x02\x12\x03\x05\x04B\n\x0c\n\x05\x04\0\x02\x02\x04\x12\x03\x05\x04\x0c\ \n\x0c\n\x05\x04\0\x02\x02\x06\x12\x03\x05\r%\n\x0c\n\x05\x04\0\x02\x02\ \x01\x12\x03\x05&:\n\x0c\n\x05\x04\0\x02\x02\x03\x12\x03\x05=A\n\x0b\n\ \x04\x04\0\x02\x03\x12\x03\x06\x040\n\x0c\n\x05\x04\0\x02\x03\x04\x12\ \x03\x06\x04\x0c\n\x0c\n\x05\x04\0\x02\x03\x06\x12\x03\x06\r\x1c\n\x0c\n\ \x05\x04\0\x02\x03\x01\x12\x03\x06\x1d(\n\x0c\n\x05\x04\0\x02\x03\x03\ \x12\x03\x06+/\n\x0b\n\x04\x04\0\x02\x04\x12\x03\x07\x04+\n\x0c\n\x05\ \x04\0\x02\x04\x04\x12\x03\x07\x04\x0c\n\x0c\n\x05\x04\0\x02\x04\x06\x12\ \x03\x07\r\x17\n\x0c\n\x05\x04\0\x02\x04\x01\x12\x03\x07\x18#\n\x0c\n\ \x05\x04\0\x02\x04\x03\x12\x03\x07&*\n\x0b\n\x04\x04\0\x02\x05\x12\x03\ \x08\x04*\n\x0c\n\x05\x04\0\x02\x05\x04\x12\x03\x08\x04\x0c\n\x0c\n\x05\ \x04\0\x02\x05\x05\x12\x03\x08\r\x13\n\x0c\n\x05\x04\0\x02\x05\x01\x12\ \x03\x08\x14\"\n\x0c\n\x05\x04\0\x02\x05\x03\x12\x03\x08%)\n\x0b\n\x04\ \x04\0\x02\x06\x12\x03\t\x04*\n\x0c\n\x05\x04\0\x02\x06\x04\x12\x03\t\ \x04\x0c\n\x0c\n\x05\x04\0\x02\x06\x05\x12\x03\t\r\x13\n\x0c\n\x05\x04\0\ \x02\x06\x01\x12\x03\t\x14\"\n\x0c\n\x05\x04\0\x02\x06\x03\x12\x03\t%)\n\ \x0b\n\x04\x04\0\x02\x07\x12\x03\n\x04,\n\x0c\n\x05\x04\0\x02\x07\x04\ \x12\x03\n\x04\x0c\n\x0c\n\x05\x04\0\x02\x07\x06\x12\x03\n\r\x1d\n\x0c\n\ \x05\x04\0\x02\x07\x01\x12\x03\n\x1e$\n\x0c\n\x05\x04\0\x02\x07\x03\x12\ \x03\n'+\n\x0b\n\x04\x04\0\x02\x08\x12\x03\x0b\x04+\n\x0c\n\x05\x04\0\ \x02\x08\x04\x12\x03\x0b\x04\x0c\n\x0c\n\x05\x04\0\x02\x08\x06\x12\x03\ \x0b\r\x17\n\x0c\n\x05\x04\0\x02\x08\x01\x12\x03\x0b\x18#\n\x0c\n\x05\ \x04\0\x02\x08\x03\x12\x03\x0b&*\n\n\n\x02\x04\x01\x12\x04\x0e\0\x12\x01\ \n\n\n\x03\x04\x01\x01\x12\x03\x0e\x08\x18\n\x0b\n\x04\x04\x01\x02\0\x12\ \x03\x0f\x04#\n\x0c\n\x05\x04\x01\x02\0\x04\x12\x03\x0f\x04\x0c\n\x0c\n\ \x05\x04\x01\x02\0\x05\x12\x03\x0f\r\x13\n\x0c\n\x05\x04\x01\x02\0\x01\ \x12\x03\x0f\x14\x1c\n\x0c\n\x05\x04\x01\x02\0\x03\x12\x03\x0f\x1f\"\n\ \x0b\n\x04\x04\x01\x02\x01\x12\x03\x10\x04+\n\x0c\n\x05\x04\x01\x02\x01\ \x04\x12\x03\x10\x04\x0c\n\x0c\n\x05\x04\x01\x02\x01\x06\x12\x03\x10\r\ \x1f\n\x0c\n\x05\x04\x01\x02\x01\x01\x12\x03\x10\x20#\n\x0c\n\x05\x04\ \x01\x02\x01\x03\x12\x03\x10&*\n\x0b\n\x04\x04\x01\x02\x02\x12\x03\x11\ \x04$\n\x0c\n\x05\x04\x01\x02\x02\x04\x12\x03\x11\x04\x0c\n\x0c\n\x05\ \x04\x01\x02\x02\x05\x12\x03\x11\r\x12\n\x0c\n\x05\x04\x01\x02\x02\x01\ \x12\x03\x11\x13\x1c\n\x0c\n\x05\x04\x01\x02\x02\x03\x12\x03\x11\x1f#\n\ \n\n\x02\x05\0\x12\x04\x14\0\x1a\x01\n\n\n\x03\x05\0\x01\x12\x03\x14\x05\ \x17\n\x0b\n\x04\x05\0\x02\0\x12\x03\x15\x04#\n\x0c\n\x05\x05\0\x02\0\ \x01\x12\x03\x15\x04\x1c\n\x0c\n\x05\x05\0\x02\0\x02\x12\x03\x15\x1f\"\n\ \x0b\n\x04\x05\0\x02\x01\x12\x03\x16\x044\n\x0c\n\x05\x05\0\x02\x01\x01\ \x12\x03\x16\x04-\n\x0c\n\x05\x05\0\x02\x01\x02\x12\x03\x1603\n\x0b\n\ \x04\x05\0\x02\x02\x12\x03\x17\x045\n\x0c\n\x05\x05\0\x02\x02\x01\x12\ \x03\x17\x04.\n\x0c\n\x05\x05\0\x02\x02\x02\x12\x03\x1714\n\x0b\n\x04\ \x05\0\x02\x03\x12\x03\x18\x04'\n\x0c\n\x05\x05\0\x02\x03\x01\x12\x03\ \x18\x04\x20\n\x0c\n\x05\x05\0\x02\x03\x02\x12\x03\x18#&\n\x0b\n\x04\x05\ \0\x02\x04\x12\x03\x19\x04(\n\x0c\n\x05\x05\0\x02\x04\x01\x12\x03\x19\ \x04!\n\x0c\n\x05\x05\0\x02\x04\x02\x12\x03\x19$'\n\n\n\x02\x05\x01\x12\ \x04\x1c\0\x1f\x01\n\n\n\x03\x05\x01\x01\x12\x03\x1c\x05\x14\n\x0b\n\x04\ \x05\x01\x02\0\x12\x03\x1d\x04)\n\x0c\n\x05\x05\x01\x02\0\x01\x12\x03\ \x1d\x04\"\n\x0c\n\x05\x05\x01\x02\0\x02\x12\x03\x1d%(\n\x0b\n\x04\x05\ \x01\x02\x01\x12\x03\x1e\x04)\n\x0c\n\x05\x05\x01\x02\x01\x01\x12\x03\ \x1e\x04\"\n\x0c\n\x05\x05\x01\x02\x01\x02\x12\x03\x1e%(\n\n\n\x02\x04\ \x02\x12\x04!\0$\x01\n\n\n\x03\x04\x02\x01\x12\x03!\x08\x20\n\x0b\n\x04\ \x04\x02\x02\0\x12\x03\"\x042\n\x0c\n\x05\x04\x02\x02\0\x04\x12\x03\"\ \x04\x0c\n\x0c\n\x05\x04\x02\x02\0\x06\x12\x03\"\r%\n\x0c\n\x05\x04\x02\ \x02\0\x01\x12\x03\"&+\n\x0c\n\x05\x04\x02\x02\0\x03\x12\x03\".1\n\x0b\n\ \x04\x04\x02\x02\x01\x12\x03#\x04>\n\x0c\n\x05\x04\x02\x02\x01\x04\x12\ \x03#\x04\x0c\n\x0c\n\x05\x04\x02\x02\x01\x06\x12\x03#\r*\n\x0c\n\x05\ \x04\x02\x02\x01\x01\x12\x03#+6\n\x0c\n\x05\x04\x02\x02\x01\x03\x12\x03#\ 9=\n\n\n\x02\x04\x03\x12\x04&\0(\x01\n\n\n\x03\x04\x03\x01\x12\x03&\x08\ \x20\n\x0b\n\x04\x04\x03\x02\0\x12\x03'\x04'\n\x0c\n\x05\x04\x03\x02\0\ \x04\x12\x03'\x04\x0c\n\x0c\n\x05\x04\x03\x02\0\x05\x12\x03'\r\x12\n\x0c\ \n\x05\x04\x03\x02\0\x01\x12\x03'\x13\x20\n\x0c\n\x05\x04\x03\x02\0\x03\ \x12\x03'#&\n\n\n\x02\x04\x04\x12\x04*\0,\x01\n\n\n\x03\x04\x04\x01\x12\ \x03*\x08%\n\x0b\n\x04\x04\x04\x02\0\x12\x03+\x04\x1e\n\x0c\n\x05\x04\ \x04\x02\0\x04\x12\x03+\x04\x0c\n\x0c\n\x05\x04\x04\x02\0\x05\x12\x03+\r\ \x12\n\x0c\n\x05\x04\x04\x02\0\x01\x12\x03+\x13\x17\n\x0c\n\x05\x04\x04\ \x02\0\x03\x12\x03+\x1a\x1d\n\n\n\x02\x04\x05\x12\x04.\01\x01\n\n\n\x03\ \x04\x05\x01\x12\x03.\x08\x17\n\x0b\n\x04\x04\x05\x02\0\x12\x03/\x042\n\ \x0c\n\x05\x04\x05\x02\0\x04\x12\x03/\x04\x0c\n\x0c\n\x05\x04\x05\x02\0\ \x06\x12\x03/\r\x20\n\x0c\n\x05\x04\x05\x02\0\x01\x12\x03/!+\n\x0c\n\x05\ \x04\x05\x02\0\x03\x12\x03/.1\n\x0b\n\x04\x04\x05\x02\x01\x12\x030\x04-\ \n\x0c\n\x05\x04\x05\x02\x01\x04\x12\x030\x04\x0c\n\x0c\n\x05\x04\x05\ \x02\x01\x06\x12\x030\r\x1a\n\x0c\n\x05\x04\x05\x02\x01\x01\x12\x030\x1b\ %\n\x0c\n\x05\x04\x05\x02\x01\x03\x12\x030(,\n\n\n\x02\x04\x06\x12\x043\ \05\x01\n\n\n\x03\x04\x06\x01\x12\x033\x08\x1b\n\x0b\n\x04\x04\x06\x02\0\ \x12\x034\x04$\n\x0c\n\x05\x04\x06\x02\0\x04\x12\x034\x04\x0c\n\x0c\n\ \x05\x04\x06\x02\0\x05\x12\x034\r\x12\n\x0c\n\x05\x04\x06\x02\0\x01\x12\ \x034\x13\x1d\n\x0c\n\x05\x04\x06\x02\0\x03\x12\x034\x20#\n\n\n\x02\x04\ \x07\x12\x047\0:\x01\n\n\n\x03\x04\x07\x01\x12\x037\x08\x15\n\x0b\n\x04\ \x04\x07\x02\0\x12\x038\x04%\n\x0c\n\x05\x04\x07\x02\0\x04\x12\x038\x04\ \x0c\n\x0c\n\x05\x04\x07\x02\0\x05\x12\x038\r\x12\n\x0c\n\x05\x04\x07\ \x02\0\x01\x12\x038\x13\x1e\n\x0c\n\x05\x04\x07\x02\0\x03\x12\x038!$\n\ \x0b\n\x04\x04\x07\x02\x01\x12\x039\x040\n\x0c\n\x05\x04\x07\x02\x01\x04\ \x12\x039\x04\x0c\n\x0c\n\x05\x04\x07\x02\x01\x05\x12\x039\r\x12\n\x0c\n\ \x05\x04\x07\x02\x01\x01\x12\x039\x13(\n\x0c\n\x05\x04\x07\x02\x01\x03\ \x12\x039+/\n\n\n\x02\x04\x08\x12\x04<\0G\x01\n\n\n\x03\x04\x08\x01\x12\ \x03<\x08\x12\n\x0b\n\x04\x04\x08\x02\0\x12\x03=\x04(\n\x0c\n\x05\x04\ \x08\x02\0\x04\x12\x03=\x04\x0c\n\x0c\n\x05\x04\x08\x02\0\x06\x12\x03=\r\ \x16\n\x0c\n\x05\x04\x08\x02\0\x01\x12\x03=\x17!\n\x0c\n\x05\x04\x08\x02\ \0\x03\x12\x03=$'\n\x0b\n\x04\x04\x08\x02\x01\x12\x03>\x04'\n\x0c\n\x05\ \x04\x08\x02\x01\x04\x12\x03>\x04\x0c\n\x0c\n\x05\x04\x08\x02\x01\x05\ \x12\x03>\r\x13\n\x0c\n\x05\x04\x08\x02\x01\x01\x12\x03>\x14\x1f\n\x0c\n\ \x05\x04\x08\x02\x01\x03\x12\x03>\"&\n\x0b\n\x04\x04\x08\x02\x02\x12\x03\ ?\x04#\n\x0c\n\x05\x04\x08\x02\x02\x04\x12\x03?\x04\x0c\n\x0c\n\x05\x04\ \x08\x02\x02\x05\x12\x03?\r\x13\n\x0c\n\x05\x04\x08\x02\x02\x01\x12\x03?\ \x14\x1b\n\x0c\n\x05\x04\x08\x02\x02\x03\x12\x03?\x1e\"\n\x0b\n\x04\x04\ \x08\x02\x03\x12\x03@\x04\x20\n\x0c\n\x05\x04\x08\x02\x03\x04\x12\x03@\ \x04\x0c\n\x0c\n\x05\x04\x08\x02\x03\x06\x12\x03@\r\x12\n\x0c\n\x05\x04\ \x08\x02\x03\x01\x12\x03@\x13\x18\n\x0c\n\x05\x04\x08\x02\x03\x03\x12\ \x03@\x1b\x1f\n\x0b\n\x04\x04\x08\x02\x04\x12\x03A\x04'\n\x0c\n\x05\x04\ \x08\x02\x04\x04\x12\x03A\x04\x0c\n\x0c\n\x05\x04\x08\x02\x04\x05\x12\ \x03A\r\x13\n\x0c\n\x05\x04\x08\x02\x04\x01\x12\x03A\x14\x1f\n\x0c\n\x05\ \x04\x08\x02\x04\x03\x12\x03A\"&\n\x0b\n\x04\x04\x08\x02\x05\x12\x03B\ \x04\x1a\n\x0c\n\x05\x04\x08\x02\x05\x04\x12\x03B\x04\x0c\n\x0c\n\x05\ \x04\x08\x02\x05\x06\x12\x03B\r\x0f\n\x0c\n\x05\x04\x08\x02\x05\x01\x12\ \x03B\x10\x12\n\x0c\n\x05\x04\x08\x02\x05\x03\x12\x03B\x15\x19\n\x0b\n\ \x04\x04\x08\x02\x06\x12\x03C\x04&\n\x0c\n\x05\x04\x08\x02\x06\x04\x12\ \x03C\x04\x0c\n\x0c\n\x05\x04\x08\x02\x06\x05\x12\x03C\r\x13\n\x0c\n\x05\ \x04\x08\x02\x06\x01\x12\x03C\x14\x1e\n\x0c\n\x05\x04\x08\x02\x06\x03\ \x12\x03C!%\n\x0b\n\x04\x04\x08\x02\x07\x12\x03D\x04\"\n\x0c\n\x05\x04\ \x08\x02\x07\x04\x12\x03D\x04\x0c\n\x0c\n\x05\x04\x08\x02\x07\x05\x12\ \x03D\r\x13\n\x0c\n\x05\x04\x08\x02\x07\x01\x12\x03D\x14\x1a\n\x0c\n\x05\ \x04\x08\x02\x07\x03\x12\x03D\x1d!\n\x0b\n\x04\x04\x08\x02\x08\x12\x03E\ \x045\n\x0c\n\x05\x04\x08\x02\x08\x04\x12\x03E\x04\x0c\n\x0c\n\x05\x04\ \x08\x02\x08\x05\x12\x03E\r\x13\n\x0c\n\x05\x04\x08\x02\x08\x01\x12\x03E\ \x14-\n\x0c\n\x05\x04\x08\x02\x08\x03\x12\x03E04\n\x0b\n\x04\x04\x08\x02\ \t\x12\x03F\x04%\n\x0c\n\x05\x04\x08\x02\t\x04\x12\x03F\x04\x0c\n\x0c\n\ \x05\x04\x08\x02\t\x05\x12\x03F\r\x13\n\x0c\n\x05\x04\x08\x02\t\x01\x12\ \x03F\x14\x1d\n\x0c\n\x05\x04\x08\x02\t\x03\x12\x03F\x20$\n\n\n\x02\x05\ \x02\x12\x04I\0T\x01\n\n\n\x03\x05\x02\x01\x12\x03I\x05\x0e\n\x0b\n\x04\ \x05\x02\x02\0\x12\x03J\x04\x16\n\x0c\n\x05\x05\x02\x02\0\x01\x12\x03J\ \x04\x0f\n\x0c\n\x05\x05\x02\x02\0\x02\x12\x03J\x12\x15\n\x0b\n\x04\x05\ \x02\x02\x01\x12\x03K\x04\x12\n\x0c\n\x05\x05\x02\x02\x01\x01\x12\x03K\ \x04\x0b\n\x0c\n\x05\x05\x02\x02\x01\x02\x12\x03K\x0e\x11\n\x0b\n\x04\ \x05\x02\x02\x02\x12\x03L\x04\x15\n\x0c\n\x05\x05\x02\x02\x02\x01\x12\ \x03L\x04\x0e\n\x0c\n\x05\x05\x02\x02\x02\x02\x12\x03L\x11\x14\n\x0b\n\ \x04\x05\x02\x02\x03\x12\x03M\x04\x12\n\x0c\n\x05\x05\x02\x02\x03\x01\ \x12\x03M\x04\x0b\n\x0c\n\x05\x05\x02\x02\x03\x02\x12\x03M\x0e\x11\n\x0b\ \n\x04\x05\x02\x02\x04\x12\x03N\x04\x15\n\x0c\n\x05\x05\x02\x02\x04\x01\ \x12\x03N\x04\x0e\n\x0c\n\x05\x05\x02\x02\x04\x02\x12\x03N\x11\x14\n\x0b\ \n\x04\x05\x02\x02\x05\x12\x03O\x04\x12\n\x0c\n\x05\x05\x02\x02\x05\x01\ \x12\x03O\x04\x0b\n\x0c\n\x05\x05\x02\x02\x05\x02\x12\x03O\x0e\x11\n\x0b\ \n\x04\x05\x02\x02\x06\x12\x03P\x04\x13\n\x0c\n\x05\x05\x02\x02\x06\x01\ \x12\x03P\x04\x0c\n\x0c\n\x05\x05\x02\x02\x06\x02\x12\x03P\x0f\x12\n\x0b\ \n\x04\x05\x02\x02\x07\x12\x03Q\x04\x11\n\x0c\n\x05\x05\x02\x02\x07\x01\ \x12\x03Q\x04\n\n\x0c\n\x05\x05\x02\x02\x07\x02\x12\x03Q\r\x10\n\x0b\n\ \x04\x05\x02\x02\x08\x12\x03R\x04\x13\n\x0c\n\x05\x05\x02\x02\x08\x01\ \x12\x03R\x04\x0c\n\x0c\n\x05\x05\x02\x02\x08\x02\x12\x03R\x0f\x12\n\x0b\ \n\x04\x05\x02\x02\t\x12\x03S\x04\x17\n\x0c\n\x05\x05\x02\x02\t\x01\x12\ \x03S\x04\x10\n\x0c\n\x05\x05\x02\x02\t\x02\x12\x03S\x13\x16\n\n\n\x02\ \x05\x03\x12\x04V\0[\x01\n\n\n\x03\x05\x03\x01\x12\x03V\x05\n\n\x0b\n\ \x04\x05\x03\x02\0\x12\x03W\x04\x1a\n\x0c\n\x05\x05\x03\x02\0\x01\x12\ \x03W\x04\x13\n\x0c\n\x05\x05\x03\x02\0\x02\x12\x03W\x16\x19\n\x0b\n\x04\ \x05\x03\x02\x01\x12\x03X\x04\x14\n\x0c\n\x05\x05\x03\x02\x01\x01\x12\ \x03X\x04\r\n\x0c\n\x05\x05\x03\x02\x01\x02\x12\x03X\x10\x13\n\x0b\n\x04\ \x05\x03\x02\x02\x12\x03Y\x04\x14\n\x0c\n\x05\x05\x03\x02\x02\x01\x12\ \x03Y\x04\r\n\x0c\n\x05\x05\x03\x02\x02\x02\x12\x03Y\x10\x13\n\x0b\n\x04\ \x05\x03\x02\x03\x12\x03Z\x04\x16\n\x0c\n\x05\x05\x03\x02\x03\x01\x12\ \x03Z\x04\x0f\n\x0c\n\x05\x05\x03\x02\x03\x02\x12\x03Z\x12\x15\n\n\n\x02\ \x05\x04\x12\x04]\0u\x01\n\n\n\x03\x05\x04\x01\x12\x03]\x05\x07\n\x0b\n\ \x04\x05\x04\x02\0\x12\x03^\x04\x15\n\x0c\n\x05\x05\x04\x02\0\x01\x12\ \x03^\x04\x0e\n\x0c\n\x05\x05\x04\x02\0\x02\x12\x03^\x11\x14\n\x0b\n\x04\ \x05\x04\x02\x01\x12\x03_\x04\x15\n\x0c\n\x05\x05\x04\x02\x01\x01\x12\ \x03_\x04\x0e\n\x0c\n\x05\x05\x04\x02\x01\x02\x12\x03_\x11\x14\n\x0b\n\ \x04\x05\x04\x02\x02\x12\x03`\x04\x11\n\x0c\n\x05\x05\x04\x02\x02\x01\ \x12\x03`\x04\n\n\x0c\n\x05\x05\x04\x02\x02\x02\x12\x03`\r\x10\n\x0b\n\ \x04\x05\x04\x02\x03\x12\x03a\x04\x14\n\x0c\n\x05\x05\x04\x02\x03\x01\ \x12\x03a\x04\r\n\x0c\n\x05\x05\x04\x02\x03\x02\x12\x03a\x10\x13\n\x0b\n\ \x04\x05\x04\x02\x04\x12\x03b\x04\x11\n\x0c\n\x05\x05\x04\x02\x04\x01\ \x12\x03b\x04\n\n\x0c\n\x05\x05\x04\x02\x04\x02\x12\x03b\r\x10\n\x0b\n\ \x04\x05\x04\x02\x05\x12\x03c\x04\x13\n\x0c\n\x05\x05\x04\x02\x05\x01\ \x12\x03c\x04\x0c\n\x0c\n\x05\x05\x04\x02\x05\x02\x12\x03c\x0f\x12\n\x0b\ \n\x04\x05\x04\x02\x06\x12\x03d\x04\x18\n\x0c\n\x05\x05\x04\x02\x06\x01\ \x12\x03d\x04\x11\n\x0c\n\x05\x05\x04\x02\x06\x02\x12\x03d\x14\x17\n\x0b\ \n\x04\x05\x04\x02\x07\x12\x03e\x04\x15\n\x0c\n\x05\x05\x04\x02\x07\x01\ \x12\x03e\x04\x0e\n\x0c\n\x05\x05\x04\x02\x07\x02\x12\x03e\x11\x14\n\x0b\ \n\x04\x05\x04\x02\x08\x12\x03f\x04\x12\n\x0c\n\x05\x05\x04\x02\x08\x01\ \x12\x03f\x04\x0b\n\x0c\n\x05\x05\x04\x02\x08\x02\x12\x03f\x0e\x11\n\x0b\ \n\x04\x05\x04\x02\t\x12\x03g\x04\x15\n\x0c\n\x05\x05\x04\x02\t\x01\x12\ \x03g\x04\x0e\n\x0c\n\x05\x05\x04\x02\t\x02\x12\x03g\x11\x14\n\x0b\n\x04\ \x05\x04\x02\n\x12\x03h\x04\x18\n\x0c\n\x05\x05\x04\x02\n\x01\x12\x03h\ \x04\x11\n\x0c\n\x05\x05\x04\x02\n\x02\x12\x03h\x14\x17\n\x0b\n\x04\x05\ \x04\x02\x0b\x12\x03i\x04\x13\n\x0c\n\x05\x05\x04\x02\x0b\x01\x12\x03i\ \x04\x0c\n\x0c\n\x05\x05\x04\x02\x0b\x02\x12\x03i\x0f\x12\n\x0b\n\x04\ \x05\x04\x02\x0c\x12\x03j\x04\x16\n\x0c\n\x05\x05\x04\x02\x0c\x01\x12\ \x03j\x04\x0f\n\x0c\n\x05\x05\x04\x02\x0c\x02\x12\x03j\x12\x15\n\x0b\n\ \x04\x05\x04\x02\r\x12\x03k\x04\x11\n\x0c\n\x05\x05\x04\x02\r\x01\x12\ \x03k\x04\n\n\x0c\n\x05\x05\x04\x02\r\x02\x12\x03k\r\x10\n\x0b\n\x04\x05\ \x04\x02\x0e\x12\x03l\x04\x13\n\x0c\n\x05\x05\x04\x02\x0e\x01\x12\x03l\ \x04\x0c\n\x0c\n\x05\x05\x04\x02\x0e\x02\x12\x03l\x0f\x12\n\x0b\n\x04\ \x05\x04\x02\x0f\x12\x03m\x04\x15\n\x0c\n\x05\x05\x04\x02\x0f\x01\x12\ \x03m\x04\x0e\n\x0c\n\x05\x05\x04\x02\x0f\x02\x12\x03m\x11\x14\n\x0b\n\ \x04\x05\x04\x02\x10\x12\x03n\x04\x11\n\x0c\n\x05\x05\x04\x02\x10\x01\ \x12\x03n\x04\t\n\x0c\n\x05\x05\x04\x02\x10\x02\x12\x03n\x0c\x10\n\x0b\n\ \x04\x05\x04\x02\x11\x12\x03o\x04\x14\n\x0c\n\x05\x05\x04\x02\x11\x01\ \x12\x03o\x04\x0c\n\x0c\n\x05\x05\x04\x02\x11\x02\x12\x03o\x0f\x13\n\x0b\ \n\x04\x05\x04\x02\x12\x12\x03p\x04\x13\n\x0c\n\x05\x05\x04\x02\x12\x01\ \x12\x03p\x04\x0b\n\x0c\n\x05\x05\x04\x02\x12\x02\x12\x03p\x0e\x12\n\x0b\ \n\x04\x05\x04\x02\x13\x12\x03q\x04\x13\n\x0c\n\x05\x05\x04\x02\x13\x01\ \x12\x03q\x04\x0b\n\x0c\n\x05\x05\x04\x02\x13\x02\x12\x03q\x0e\x12\n\x0b\ \n\x04\x05\x04\x02\x14\x12\x03r\x04\x14\n\x0c\n\x05\x05\x04\x02\x14\x01\ \x12\x03r\x04\x0c\n\x0c\n\x05\x05\x04\x02\x14\x02\x12\x03r\x0f\x13\n\x0b\ \n\x04\x05\x04\x02\x15\x12\x03s\x04\x15\n\x0c\n\x05\x05\x04\x02\x15\x01\ \x12\x03s\x04\r\n\x0c\n\x05\x05\x04\x02\x15\x02\x12\x03s\x10\x14\n\x0b\n\ \x04\x05\x04\x02\x16\x12\x03t\x04\x12\n\x0c\n\x05\x05\x04\x02\x16\x01\ \x12\x03t\x04\n\n\x0c\n\x05\x05\x04\x02\x16\x02\x12\x03t\r\x11\n\n\n\x02\ \x04\t\x12\x04w\0}\x01\n\n\n\x03\x04\t\x01\x12\x03w\x08\x18\n\x0b\n\x04\ \x04\t\x02\0\x12\x03x\x04\"\n\x0c\n\x05\x04\t\x02\0\x04\x12\x03x\x04\x0c\ \n\x0c\n\x05\x04\t\x02\0\x05\x12\x03x\r\x13\n\x0c\n\x05\x04\t\x02\0\x01\ \x12\x03x\x14\x1b\n\x0c\n\x05\x04\t\x02\0\x03\x12\x03x\x1e!\n\x0b\n\x04\ \x04\t\x02\x01\x12\x03y\x04\x20\n\x0c\n\x05\x04\t\x02\x01\x04\x12\x03y\ \x04\x0c\n\x0c\n\x05\x04\t\x02\x01\x05\x12\x03y\r\x12\n\x0c\n\x05\x04\t\ \x02\x01\x01\x12\x03y\x13\x19\n\x0c\n\x05\x04\t\x02\x01\x03\x12\x03y\x1c\ \x1f\n\x0b\n\x04\x04\t\x02\x02\x12\x03z\x04#\n\x0c\n\x05\x04\t\x02\x02\ \x04\x12\x03z\x04\x0c\n\x0c\n\x05\x04\t\x02\x02\x05\x12\x03z\r\x12\n\x0c\ \n\x05\x04\t\x02\x02\x01\x12\x03z\x13\x1c\n\x0c\n\x05\x04\t\x02\x02\x03\ \x12\x03z\x1f\"\n\x0b\n\x04\x04\t\x02\x03\x12\x03{\x04$\n\x0c\n\x05\x04\ \t\x02\x03\x04\x12\x03{\x04\x0c\n\x0c\n\x05\x04\t\x02\x03\x05\x12\x03{\r\ \x13\n\x0c\n\x05\x04\t\x02\x03\x01\x12\x03{\x14\x1d\n\x0c\n\x05\x04\t\ \x02\x03\x03\x12\x03{\x20#\n\x0b\n\x04\x04\t\x02\x04\x12\x03|\x04'\n\x0c\ \n\x05\x04\t\x02\x04\x04\x12\x03|\x04\x0c\n\x0c\n\x05\x04\t\x02\x04\x05\ \x12\x03|\r\x12\n\x0c\n\x05\x04\t\x02\x04\x01\x12\x03|\x13\x20\n\x0c\n\ \x05\x04\t\x02\x04\x03\x12\x03|#&\n\x0b\n\x02\x04\n\x12\x05\x7f\0\x83\ \x01\x01\n\n\n\x03\x04\n\x01\x12\x03\x7f\x08\x12\n\x0c\n\x04\x04\n\x02\0\ \x12\x04\x80\x01\x04\x20\n\r\n\x05\x04\n\x02\0\x04\x12\x04\x80\x01\x04\ \x0c\n\r\n\x05\x04\n\x02\0\x05\x12\x04\x80\x01\r\x11\n\r\n\x05\x04\n\x02\ \0\x01\x12\x04\x80\x01\x12\x19\n\r\n\x05\x04\n\x02\0\x03\x12\x04\x80\x01\ \x1c\x1f\n\x0c\n\x04\x04\n\x02\x01\x12\x04\x81\x01\x04)\n\r\n\x05\x04\n\ \x02\x01\x04\x12\x04\x81\x01\x04\x0c\n\r\n\x05\x04\n\x02\x01\x06\x12\x04\ \x81\x01\r\x1f\n\r\n\x05\x04\n\x02\x01\x01\x12\x04\x81\x01\x20\"\n\r\n\ \x05\x04\n\x02\x01\x03\x12\x04\x81\x01%(\n\x0c\n\x04\x04\n\x02\x02\x12\ \x04\x82\x01\x04#\n\r\n\x05\x04\n\x02\x02\x04\x12\x04\x82\x01\x04\x0c\n\ \r\n\x05\x04\n\x02\x02\x05\x12\x04\x82\x01\r\x13\n\r\n\x05\x04\n\x02\x02\ \x01\x12\x04\x82\x01\x14\x1c\n\r\n\x05\x04\n\x02\x02\x03\x12\x04\x82\x01\ \x1f\"\n\x0c\n\x02\x04\x0b\x12\x06\x85\x01\0\x87\x01\x01\n\x0b\n\x03\x04\ \x0b\x01\x12\x04\x85\x01\x08\x1a\n\x0c\n\x04\x04\x0b\x02\0\x12\x04\x86\ \x01\x04%\n\r\n\x05\x04\x0b\x02\0\x04\x12\x04\x86\x01\x04\x0c\n\r\n\x05\ \x04\x0b\x02\0\x05\x12\x04\x86\x01\r\x13\n\r\n\x05\x04\x0b\x02\0\x01\x12\ \x04\x86\x01\x14\x1e\n\r\n\x05\x04\x0b\x02\0\x03\x12\x04\x86\x01!$\n\x0c\ \n\x02\x04\x0c\x12\x06\x89\x01\0\x92\x01\x01\n\x0b\n\x03\x04\x0c\x01\x12\ \x04\x89\x01\x08\x11\n\x0c\n\x04\x04\x0c\x02\0\x12\x04\x8a\x01\x04-\n\r\ \n\x05\x04\x0c\x02\0\x04\x12\x04\x8a\x01\x04\x0c\n\r\n\x05\x04\x0c\x02\0\ \x05\x12\x04\x8a\x01\r\x13\n\r\n\x05\x04\x0c\x02\0\x01\x12\x04\x8a\x01\ \x14&\n\r\n\x05\x04\x0c\x02\0\x03\x12\x04\x8a\x01),\n\x0c\n\x04\x04\x0c\ \x02\x01\x12\x04\x8b\x01\x047\n\r\n\x05\x04\x0c\x02\x01\x04\x12\x04\x8b\ \x01\x04\x0c\n\r\n\x05\x04\x0c\x02\x01\x06\x12\x04\x8b\x01\r\x18\n\r\n\ \x05\x04\x0c\x02\x01\x01\x12\x04\x8b\x01\x19/\n\r\n\x05\x04\x0c\x02\x01\ \x03\x12\x04\x8b\x0126\n\x0c\n\x04\x04\x0c\x02\x02\x12\x04\x8c\x01\x04;\ \n\r\n\x05\x04\x0c\x02\x02\x04\x12\x04\x8c\x01\x04\x0c\n\r\n\x05\x04\x0c\ \x02\x02\x06\x12\x04\x8c\x01\r\x18\n\r\n\x05\x04\x0c\x02\x02\x01\x12\x04\ \x8c\x01\x193\n\r\n\x05\x04\x0c\x02\x02\x03\x12\x04\x8c\x016:\n\x0c\n\ \x04\x04\x0c\x02\x03\x12\x04\x8d\x01\x04F\n\r\n\x05\x04\x0c\x02\x03\x04\ \x12\x04\x8d\x01\x04\x0c\n\r\n\x05\x04\x0c\x02\x03\x06\x12\x04\x8d\x01\r\ \x1f\n\r\n\x05\x04\x0c\x02\x03\x01\x12\x04\x8d\x01\x20>\n\r\n\x05\x04\ \x0c\x02\x03\x03\x12\x04\x8d\x01AE\n\x0c\n\x04\x04\x0c\x02\x04\x12\x04\ \x8e\x01\x044\n\r\n\x05\x04\x0c\x02\x04\x04\x12\x04\x8e\x01\x04\x0c\n\r\ \n\x05\x04\x0c\x02\x04\x05\x12\x04\x8e\x01\r\x12\n\r\n\x05\x04\x0c\x02\ \x04\x01\x12\x04\x8e\x01\x13,\n\r\n\x05\x04\x0c\x02\x04\x03\x12\x04\x8e\ \x01/3\n\x0c\n\x04\x04\x0c\x02\x05\x12\x04\x8f\x01\x04%\n\r\n\x05\x04\ \x0c\x02\x05\x04\x12\x04\x8f\x01\x04\x0c\n\r\n\x05\x04\x0c\x02\x05\x05\ \x12\x04\x8f\x01\r\x12\n\r\n\x05\x04\x0c\x02\x05\x01\x12\x04\x8f\x01\x13\ \x1d\n\r\n\x05\x04\x0c\x02\x05\x03\x12\x04\x8f\x01\x20$\n\x0c\n\x04\x04\ \x0c\x02\x06\x12\x04\x90\x01\x04-\n\r\n\x05\x04\x0c\x02\x06\x04\x12\x04\ \x90\x01\x04\x0c\n\r\n\x05\x04\x0c\x02\x06\x06\x12\x04\x90\x01\r\x18\n\r\ \n\x05\x04\x0c\x02\x06\x01\x12\x04\x90\x01\x19%\n\r\n\x05\x04\x0c\x02\ \x06\x03\x12\x04\x90\x01(,\n\x0c\n\x04\x04\x0c\x02\x07\x12\x04\x91\x01\ \x04+\n\r\n\x05\x04\x0c\x02\x07\x04\x12\x04\x91\x01\x04\x0c\n\r\n\x05\ \x04\x0c\x02\x07\x06\x12\x04\x91\x01\r\x20\n\r\n\x05\x04\x0c\x02\x07\x01\ \x12\x04\x91\x01!#\n\r\n\x05\x04\x0c\x02\x07\x03\x12\x04\x91\x01&*\n\x0c\ \n\x02\x05\x05\x12\x06\x94\x01\0\x97\x01\x01\n\x0b\n\x03\x05\x05\x01\x12\ \x04\x94\x01\x05\x10\n\x0c\n\x04\x05\x05\x02\0\x12\x04\x95\x01\x04\x12\n\ \r\n\x05\x05\x05\x02\0\x01\x12\x04\x95\x01\x04\x0b\n\r\n\x05\x05\x05\x02\ \0\x02\x12\x04\x95\x01\x0e\x11\n\x0c\n\x04\x05\x05\x02\x01\x12\x04\x96\ \x01\x04\x13\n\r\n\x05\x05\x05\x02\x01\x01\x12\x04\x96\x01\x04\x0c\n\r\n\ \x05\x05\x05\x02\x01\x02\x12\x04\x96\x01\x0f\x12\n\x0c\n\x02\x04\r\x12\ \x06\x99\x01\0\x9c\x01\x01\n\x0b\n\x03\x04\r\x01\x12\x04\x99\x01\x08\x13\ \n\x0c\n\x04\x04\r\x02\0\x12\x04\x9a\x01\x04.\n\r\n\x05\x04\r\x02\0\x04\ \x12\x04\x9a\x01\x04\x0c\n\r\n\x05\x04\r\x02\0\x06\x12\x04\x9a\x01\r\x1f\ \n\r\n\x05\x04\r\x02\0\x01\x12\x04\x9a\x01\x20'\n\r\n\x05\x04\r\x02\0\ \x03\x12\x04\x9a\x01*-\n\x0c\n\x04\x04\r\x02\x01\x12\x04\x9b\x01\x040\n\ \r\n\x05\x04\r\x02\x01\x04\x12\x04\x9b\x01\x04\x0c\n\r\n\x05\x04\r\x02\ \x01\x06\x12\x04\x9b\x01\r\x20\n\r\n\x05\x04\r\x02\x01\x01\x12\x04\x9b\ \x01!)\n\r\n\x05\x04\r\x02\x01\x03\x12\x04\x9b\x01,/\n\x0c\n\x02\x04\x0e\ \x12\x06\x9e\x01\0\x9f\x01\x01\n\x0b\n\x03\x04\x0e\x01\x12\x04\x9e\x01\ \x08\x1a\n\x0c\n\x02\x04\x0f\x12\x06\xa1\x01\0\xa4\x01\x01\n\x0b\n\x03\ \x04\x0f\x01\x12\x04\xa1\x01\x08\x1b\n\x0c\n\x04\x04\x0f\x02\0\x12\x04\ \xa2\x01\x04'\n\r\n\x05\x04\x0f\x02\0\x04\x12\x04\xa2\x01\x04\x0c\n\r\n\ \x05\x04\x0f\x02\0\x05\x12\x04\xa2\x01\r\x13\n\r\n\x05\x04\x0f\x02\0\x01\ \x12\x04\xa2\x01\x14\x20\n\r\n\x05\x04\x0f\x02\0\x03\x12\x04\xa2\x01#&\n\ \x0c\n\x04\x04\x0f\x02\x01\x12\x04\xa3\x01\x04%\n\r\n\x05\x04\x0f\x02\ \x01\x04\x12\x04\xa3\x01\x04\x0c\n\r\n\x05\x04\x0f\x02\x01\x05\x12\x04\ \xa3\x01\r\x13\n\r\n\x05\x04\x0f\x02\x01\x01\x12\x04\xa3\x01\x14\x1e\n\r\ \n\x05\x04\x0f\x02\x01\x03\x12\x04\xa3\x01!$\ "; static mut file_descriptor_proto_lazy: ::protobuf::lazy::Lazy<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const ::protobuf::descriptor::FileDescriptorProto, }; fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto { ::protobuf::parse_from_bytes(file_descriptor_proto_data).unwrap() } pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto { unsafe { file_descriptor_proto_lazy.get(|| { parse_descriptor_proto() }) } }