1 // This file is generated by rust-protobuf 2.27.1. Do not edit 2 // @generated 3 4 // https://github.com/rust-lang/rust-clippy/issues/702 5 #![allow(unknown_lints)] 6 #![allow(clippy::all)] 7 8 #![allow(unused_attributes)] 9 #![cfg_attr(rustfmt, rustfmt::skip)] 10 11 #![allow(box_pointers)] 12 #![allow(dead_code)] 13 #![allow(missing_docs)] 14 #![allow(non_camel_case_types)] 15 #![allow(non_snake_case)] 16 #![allow(non_upper_case_globals)] 17 #![allow(trivial_casts)] 18 #![allow(unused_imports)] 19 #![allow(unused_results)] 20 //! Generated file from `key.proto` 21 22 /// Generated files are compatible only with the same version 23 /// of protobuf runtime. 24 // const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_27_1; 25 26 #[derive(PartialEq,Clone,Default,Debug)] 27 pub struct KeyPrivileges { 28 // message fields 29 add: ::std::option::Option<bool>, 30 remove: ::std::option::Option<bool>, 31 update: ::std::option::Option<bool>, 32 // special fields 33 pub unknown_fields: ::protobuf::UnknownFields, 34 pub cached_size: ::protobuf::CachedSize, 35 } 36 37 impl<'a> ::std::default::Default for &'a KeyPrivileges { default() -> &'a KeyPrivileges38 fn default() -> &'a KeyPrivileges { 39 <KeyPrivileges as ::protobuf::Message>::default_instance() 40 } 41 } 42 43 impl KeyPrivileges { new() -> KeyPrivileges44 pub fn new() -> KeyPrivileges { 45 ::std::default::Default::default() 46 } 47 48 // optional bool add = 2; 49 50 get_add(&self) -> bool51 pub fn get_add(&self) -> bool { 52 self.add.unwrap_or(true) 53 } clear_add(&mut self)54 pub fn clear_add(&mut self) { 55 self.add = ::std::option::Option::None; 56 } 57 has_add(&self) -> bool58 pub fn has_add(&self) -> bool { 59 self.add.is_some() 60 } 61 62 // Param is passed by value, moved set_add(&mut self, v: bool)63 pub fn set_add(&mut self, v: bool) { 64 self.add = ::std::option::Option::Some(v); 65 } 66 67 // optional bool remove = 3; 68 69 get_remove(&self) -> bool70 pub fn get_remove(&self) -> bool { 71 self.remove.unwrap_or(true) 72 } clear_remove(&mut self)73 pub fn clear_remove(&mut self) { 74 self.remove = ::std::option::Option::None; 75 } 76 has_remove(&self) -> bool77 pub fn has_remove(&self) -> bool { 78 self.remove.is_some() 79 } 80 81 // Param is passed by value, moved set_remove(&mut self, v: bool)82 pub fn set_remove(&mut self, v: bool) { 83 self.remove = ::std::option::Option::Some(v); 84 } 85 86 // optional bool update = 4; 87 88 get_update(&self) -> bool89 pub fn get_update(&self) -> bool { 90 self.update.unwrap_or(true) 91 } clear_update(&mut self)92 pub fn clear_update(&mut self) { 93 self.update = ::std::option::Option::None; 94 } 95 has_update(&self) -> bool96 pub fn has_update(&self) -> bool { 97 self.update.is_some() 98 } 99 100 // Param is passed by value, moved set_update(&mut self, v: bool)101 pub fn set_update(&mut self, v: bool) { 102 self.update = ::std::option::Option::Some(v); 103 } 104 } 105 106 impl ::protobuf::Message for KeyPrivileges { is_initialized(&self) -> bool107 fn is_initialized(&self) -> bool { 108 true 109 } 110 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>111 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 112 while !is.eof()? { 113 let (field_number, wire_type) = is.read_tag_unpack()?; 114 match field_number { 115 2 => { 116 if wire_type != ::protobuf::wire_format::WireTypeVarint { 117 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 118 } 119 let tmp = is.read_bool()?; 120 self.add = ::std::option::Option::Some(tmp); 121 }, 122 3 => { 123 if wire_type != ::protobuf::wire_format::WireTypeVarint { 124 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 125 } 126 let tmp = is.read_bool()?; 127 self.remove = ::std::option::Option::Some(tmp); 128 }, 129 4 => { 130 if wire_type != ::protobuf::wire_format::WireTypeVarint { 131 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 132 } 133 let tmp = is.read_bool()?; 134 self.update = ::std::option::Option::Some(tmp); 135 }, 136 _ => { 137 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 138 }, 139 }; 140 } 141 ::std::result::Result::Ok(()) 142 } 143 144 // Compute sizes of nested messages 145 #[allow(unused_variables)] compute_size(&self) -> u32146 fn compute_size(&self) -> u32 { 147 let mut my_size = 0; 148 if let Some(v) = self.add { 149 my_size += 2; 150 } 151 if let Some(v) = self.remove { 152 my_size += 2; 153 } 154 if let Some(v) = self.update { 155 my_size += 2; 156 } 157 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 158 self.cached_size.set(my_size); 159 my_size 160 } 161 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>162 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 163 if let Some(v) = self.add { 164 os.write_bool(2, v)?; 165 } 166 if let Some(v) = self.remove { 167 os.write_bool(3, v)?; 168 } 169 if let Some(v) = self.update { 170 os.write_bool(4, v)?; 171 } 172 os.write_unknown_fields(self.get_unknown_fields())?; 173 ::std::result::Result::Ok(()) 174 } 175 get_cached_size(&self) -> u32176 fn get_cached_size(&self) -> u32 { 177 self.cached_size.get() 178 } 179 get_unknown_fields(&self) -> &::protobuf::UnknownFields180 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 181 &self.unknown_fields 182 } 183 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields184 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 185 &mut self.unknown_fields 186 } 187 as_any(&self) -> &dyn (::std::any::Any)188 fn as_any(&self) -> &dyn (::std::any::Any) { 189 self as &dyn (::std::any::Any) 190 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)191 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 192 self as &mut dyn (::std::any::Any) 193 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>194 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 195 self 196 } 197 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor198 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 199 Self::descriptor_static() 200 } 201 new() -> KeyPrivileges202 fn new() -> KeyPrivileges { 203 KeyPrivileges::new() 204 } 205 default_instance() -> &'static KeyPrivileges206 fn default_instance() -> &'static KeyPrivileges { 207 static instance: ::protobuf::rt::LazyV2<KeyPrivileges> = ::protobuf::rt::LazyV2::INIT; 208 instance.get(KeyPrivileges::new) 209 } 210 } 211 212 impl ::protobuf::Clear for KeyPrivileges { clear(&mut self)213 fn clear(&mut self) { 214 self.add = ::std::option::Option::None; 215 self.remove = ::std::option::Option::None; 216 self.update = ::std::option::Option::None; 217 self.unknown_fields.clear(); 218 } 219 } 220 221 impl ::protobuf::reflect::ProtobufValue for KeyPrivileges { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef222 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 223 ::protobuf::reflect::ReflectValueRef::Message(self) 224 } 225 } 226 227 #[derive(PartialEq,Clone,Default,Debug)] 228 pub struct KeyProviderData { 229 // message fields 230 pub entry: ::protobuf::RepeatedField<KeyProviderData_Entry>, 231 // special fields 232 pub unknown_fields: ::protobuf::UnknownFields, 233 pub cached_size: ::protobuf::CachedSize, 234 } 235 236 impl<'a> ::std::default::Default for &'a KeyProviderData { default() -> &'a KeyProviderData237 fn default() -> &'a KeyProviderData { 238 <KeyProviderData as ::protobuf::Message>::default_instance() 239 } 240 } 241 242 impl KeyProviderData { new() -> KeyProviderData243 pub fn new() -> KeyProviderData { 244 ::std::default::Default::default() 245 } 246 247 // repeated .cryptohome.KeyProviderData.Entry entry = 1; 248 249 get_entry(&self) -> &[KeyProviderData_Entry]250 pub fn get_entry(&self) -> &[KeyProviderData_Entry] { 251 &self.entry 252 } clear_entry(&mut self)253 pub fn clear_entry(&mut self) { 254 self.entry.clear(); 255 } 256 257 // Param is passed by value, moved set_entry(&mut self, v: ::protobuf::RepeatedField<KeyProviderData_Entry>)258 pub fn set_entry(&mut self, v: ::protobuf::RepeatedField<KeyProviderData_Entry>) { 259 self.entry = v; 260 } 261 262 // Mutable pointer to the field. mut_entry(&mut self) -> &mut ::protobuf::RepeatedField<KeyProviderData_Entry>263 pub fn mut_entry(&mut self) -> &mut ::protobuf::RepeatedField<KeyProviderData_Entry> { 264 &mut self.entry 265 } 266 267 // Take field take_entry(&mut self) -> ::protobuf::RepeatedField<KeyProviderData_Entry>268 pub fn take_entry(&mut self) -> ::protobuf::RepeatedField<KeyProviderData_Entry> { 269 ::std::mem::replace(&mut self.entry, ::protobuf::RepeatedField::new()) 270 } 271 } 272 273 impl ::protobuf::Message for KeyProviderData { is_initialized(&self) -> bool274 fn is_initialized(&self) -> bool { 275 for v in &self.entry { 276 if !v.is_initialized() { 277 return false; 278 } 279 }; 280 true 281 } 282 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>283 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 284 while !is.eof()? { 285 let (field_number, wire_type) = is.read_tag_unpack()?; 286 match field_number { 287 1 => { 288 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.entry)?; 289 }, 290 _ => { 291 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 292 }, 293 }; 294 } 295 ::std::result::Result::Ok(()) 296 } 297 298 // Compute sizes of nested messages 299 #[allow(unused_variables)] compute_size(&self) -> u32300 fn compute_size(&self) -> u32 { 301 let mut my_size = 0; 302 for value in &self.entry { 303 let len = value.compute_size(); 304 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; 305 }; 306 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 307 self.cached_size.set(my_size); 308 my_size 309 } 310 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>311 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 312 for v in &self.entry { 313 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; 314 os.write_raw_varint32(v.get_cached_size())?; 315 v.write_to_with_cached_sizes(os)?; 316 }; 317 os.write_unknown_fields(self.get_unknown_fields())?; 318 ::std::result::Result::Ok(()) 319 } 320 get_cached_size(&self) -> u32321 fn get_cached_size(&self) -> u32 { 322 self.cached_size.get() 323 } 324 get_unknown_fields(&self) -> &::protobuf::UnknownFields325 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 326 &self.unknown_fields 327 } 328 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields329 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 330 &mut self.unknown_fields 331 } 332 as_any(&self) -> &dyn (::std::any::Any)333 fn as_any(&self) -> &dyn (::std::any::Any) { 334 self as &dyn (::std::any::Any) 335 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)336 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 337 self as &mut dyn (::std::any::Any) 338 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>339 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 340 self 341 } 342 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor343 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 344 Self::descriptor_static() 345 } 346 new() -> KeyProviderData347 fn new() -> KeyProviderData { 348 KeyProviderData::new() 349 } 350 default_instance() -> &'static KeyProviderData351 fn default_instance() -> &'static KeyProviderData { 352 static instance: ::protobuf::rt::LazyV2<KeyProviderData> = ::protobuf::rt::LazyV2::INIT; 353 instance.get(KeyProviderData::new) 354 } 355 } 356 357 impl ::protobuf::Clear for KeyProviderData { clear(&mut self)358 fn clear(&mut self) { 359 self.entry.clear(); 360 self.unknown_fields.clear(); 361 } 362 } 363 364 impl ::protobuf::reflect::ProtobufValue for KeyProviderData { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef365 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 366 ::protobuf::reflect::ReflectValueRef::Message(self) 367 } 368 } 369 370 #[derive(PartialEq,Clone,Default,Debug)] 371 pub struct KeyProviderData_Entry { 372 // message fields 373 name: ::protobuf::SingularField<::std::string::String>, 374 number: ::std::option::Option<i64>, 375 bytes: ::protobuf::SingularField<::std::vec::Vec<u8>>, 376 // special fields 377 pub unknown_fields: ::protobuf::UnknownFields, 378 pub cached_size: ::protobuf::CachedSize, 379 } 380 381 impl<'a> ::std::default::Default for &'a KeyProviderData_Entry { default() -> &'a KeyProviderData_Entry382 fn default() -> &'a KeyProviderData_Entry { 383 <KeyProviderData_Entry as ::protobuf::Message>::default_instance() 384 } 385 } 386 387 impl KeyProviderData_Entry { new() -> KeyProviderData_Entry388 pub fn new() -> KeyProviderData_Entry { 389 ::std::default::Default::default() 390 } 391 392 // optional string name = 1; 393 394 get_name(&self) -> &str395 pub fn get_name(&self) -> &str { 396 match self.name.as_ref() { 397 Some(v) => &v, 398 None => "", 399 } 400 } clear_name(&mut self)401 pub fn clear_name(&mut self) { 402 self.name.clear(); 403 } 404 has_name(&self) -> bool405 pub fn has_name(&self) -> bool { 406 self.name.is_some() 407 } 408 409 // Param is passed by value, moved set_name(&mut self, v: ::std::string::String)410 pub fn set_name(&mut self, v: ::std::string::String) { 411 self.name = ::protobuf::SingularField::some(v); 412 } 413 414 // Mutable pointer to the field. 415 // If field is not initialized, it is initialized with default value first. mut_name(&mut self) -> &mut ::std::string::String416 pub fn mut_name(&mut self) -> &mut ::std::string::String { 417 if self.name.is_none() { 418 self.name.set_default(); 419 } 420 self.name.as_mut().unwrap() 421 } 422 423 // Take field take_name(&mut self) -> ::std::string::String424 pub fn take_name(&mut self) -> ::std::string::String { 425 self.name.take().unwrap_or_else(|| ::std::string::String::new()) 426 } 427 428 // optional int64 number = 2; 429 430 get_number(&self) -> i64431 pub fn get_number(&self) -> i64 { 432 self.number.unwrap_or(0) 433 } clear_number(&mut self)434 pub fn clear_number(&mut self) { 435 self.number = ::std::option::Option::None; 436 } 437 has_number(&self) -> bool438 pub fn has_number(&self) -> bool { 439 self.number.is_some() 440 } 441 442 // Param is passed by value, moved set_number(&mut self, v: i64)443 pub fn set_number(&mut self, v: i64) { 444 self.number = ::std::option::Option::Some(v); 445 } 446 447 // optional bytes bytes = 3; 448 449 get_bytes(&self) -> &[u8]450 pub fn get_bytes(&self) -> &[u8] { 451 match self.bytes.as_ref() { 452 Some(v) => &v, 453 None => &[], 454 } 455 } clear_bytes(&mut self)456 pub fn clear_bytes(&mut self) { 457 self.bytes.clear(); 458 } 459 has_bytes(&self) -> bool460 pub fn has_bytes(&self) -> bool { 461 self.bytes.is_some() 462 } 463 464 // Param is passed by value, moved set_bytes(&mut self, v: ::std::vec::Vec<u8>)465 pub fn set_bytes(&mut self, v: ::std::vec::Vec<u8>) { 466 self.bytes = ::protobuf::SingularField::some(v); 467 } 468 469 // Mutable pointer to the field. 470 // If field is not initialized, it is initialized with default value first. mut_bytes(&mut self) -> &mut ::std::vec::Vec<u8>471 pub fn mut_bytes(&mut self) -> &mut ::std::vec::Vec<u8> { 472 if self.bytes.is_none() { 473 self.bytes.set_default(); 474 } 475 self.bytes.as_mut().unwrap() 476 } 477 478 // Take field take_bytes(&mut self) -> ::std::vec::Vec<u8>479 pub fn take_bytes(&mut self) -> ::std::vec::Vec<u8> { 480 self.bytes.take().unwrap_or_else(|| ::std::vec::Vec::new()) 481 } 482 } 483 484 impl ::protobuf::Message for KeyProviderData_Entry { is_initialized(&self) -> bool485 fn is_initialized(&self) -> bool { 486 true 487 } 488 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>489 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 490 while !is.eof()? { 491 let (field_number, wire_type) = is.read_tag_unpack()?; 492 match field_number { 493 1 => { 494 ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.name)?; 495 }, 496 2 => { 497 if wire_type != ::protobuf::wire_format::WireTypeVarint { 498 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 499 } 500 let tmp = is.read_int64()?; 501 self.number = ::std::option::Option::Some(tmp); 502 }, 503 3 => { 504 ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.bytes)?; 505 }, 506 _ => { 507 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 508 }, 509 }; 510 } 511 ::std::result::Result::Ok(()) 512 } 513 514 // Compute sizes of nested messages 515 #[allow(unused_variables)] compute_size(&self) -> u32516 fn compute_size(&self) -> u32 { 517 let mut my_size = 0; 518 if let Some(ref v) = self.name.as_ref() { 519 my_size += ::protobuf::rt::string_size(1, &v); 520 } 521 if let Some(v) = self.number { 522 my_size += ::protobuf::rt::value_size(2, v, ::protobuf::wire_format::WireTypeVarint); 523 } 524 if let Some(ref v) = self.bytes.as_ref() { 525 my_size += ::protobuf::rt::bytes_size(3, &v); 526 } 527 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 528 self.cached_size.set(my_size); 529 my_size 530 } 531 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>532 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 533 if let Some(ref v) = self.name.as_ref() { 534 os.write_string(1, &v)?; 535 } 536 if let Some(v) = self.number { 537 os.write_int64(2, v)?; 538 } 539 if let Some(ref v) = self.bytes.as_ref() { 540 os.write_bytes(3, &v)?; 541 } 542 os.write_unknown_fields(self.get_unknown_fields())?; 543 ::std::result::Result::Ok(()) 544 } 545 get_cached_size(&self) -> u32546 fn get_cached_size(&self) -> u32 { 547 self.cached_size.get() 548 } 549 get_unknown_fields(&self) -> &::protobuf::UnknownFields550 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 551 &self.unknown_fields 552 } 553 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields554 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 555 &mut self.unknown_fields 556 } 557 as_any(&self) -> &dyn (::std::any::Any)558 fn as_any(&self) -> &dyn (::std::any::Any) { 559 self as &dyn (::std::any::Any) 560 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)561 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 562 self as &mut dyn (::std::any::Any) 563 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>564 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 565 self 566 } 567 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor568 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 569 Self::descriptor_static() 570 } 571 new() -> KeyProviderData_Entry572 fn new() -> KeyProviderData_Entry { 573 KeyProviderData_Entry::new() 574 } 575 default_instance() -> &'static KeyProviderData_Entry576 fn default_instance() -> &'static KeyProviderData_Entry { 577 static instance: ::protobuf::rt::LazyV2<KeyProviderData_Entry> = ::protobuf::rt::LazyV2::INIT; 578 instance.get(KeyProviderData_Entry::new) 579 } 580 } 581 582 impl ::protobuf::Clear for KeyProviderData_Entry { clear(&mut self)583 fn clear(&mut self) { 584 self.name.clear(); 585 self.number = ::std::option::Option::None; 586 self.bytes.clear(); 587 self.unknown_fields.clear(); 588 } 589 } 590 591 impl ::protobuf::reflect::ProtobufValue for KeyProviderData_Entry { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef592 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 593 ::protobuf::reflect::ReflectValueRef::Message(self) 594 } 595 } 596 597 #[derive(PartialEq,Clone,Default,Debug)] 598 pub struct ChallengePublicKeyInfo { 599 // message fields 600 public_key_spki_der: ::protobuf::SingularField<::std::vec::Vec<u8>>, 601 pub signature_algorithm: ::std::vec::Vec<ChallengeSignatureAlgorithm>, 602 // special fields 603 pub unknown_fields: ::protobuf::UnknownFields, 604 pub cached_size: ::protobuf::CachedSize, 605 } 606 607 impl<'a> ::std::default::Default for &'a ChallengePublicKeyInfo { default() -> &'a ChallengePublicKeyInfo608 fn default() -> &'a ChallengePublicKeyInfo { 609 <ChallengePublicKeyInfo as ::protobuf::Message>::default_instance() 610 } 611 } 612 613 impl ChallengePublicKeyInfo { new() -> ChallengePublicKeyInfo614 pub fn new() -> ChallengePublicKeyInfo { 615 ::std::default::Default::default() 616 } 617 618 // optional bytes public_key_spki_der = 1; 619 620 get_public_key_spki_der(&self) -> &[u8]621 pub fn get_public_key_spki_der(&self) -> &[u8] { 622 match self.public_key_spki_der.as_ref() { 623 Some(v) => &v, 624 None => &[], 625 } 626 } clear_public_key_spki_der(&mut self)627 pub fn clear_public_key_spki_der(&mut self) { 628 self.public_key_spki_der.clear(); 629 } 630 has_public_key_spki_der(&self) -> bool631 pub fn has_public_key_spki_der(&self) -> bool { 632 self.public_key_spki_der.is_some() 633 } 634 635 // Param is passed by value, moved set_public_key_spki_der(&mut self, v: ::std::vec::Vec<u8>)636 pub fn set_public_key_spki_der(&mut self, v: ::std::vec::Vec<u8>) { 637 self.public_key_spki_der = ::protobuf::SingularField::some(v); 638 } 639 640 // Mutable pointer to the field. 641 // If field is not initialized, it is initialized with default value first. mut_public_key_spki_der(&mut self) -> &mut ::std::vec::Vec<u8>642 pub fn mut_public_key_spki_der(&mut self) -> &mut ::std::vec::Vec<u8> { 643 if self.public_key_spki_der.is_none() { 644 self.public_key_spki_der.set_default(); 645 } 646 self.public_key_spki_der.as_mut().unwrap() 647 } 648 649 // Take field take_public_key_spki_der(&mut self) -> ::std::vec::Vec<u8>650 pub fn take_public_key_spki_der(&mut self) -> ::std::vec::Vec<u8> { 651 self.public_key_spki_der.take().unwrap_or_else(|| ::std::vec::Vec::new()) 652 } 653 654 // repeated .cryptohome.ChallengeSignatureAlgorithm signature_algorithm = 2; 655 656 get_signature_algorithm(&self) -> &[ChallengeSignatureAlgorithm]657 pub fn get_signature_algorithm(&self) -> &[ChallengeSignatureAlgorithm] { 658 &self.signature_algorithm 659 } clear_signature_algorithm(&mut self)660 pub fn clear_signature_algorithm(&mut self) { 661 self.signature_algorithm.clear(); 662 } 663 664 // Param is passed by value, moved set_signature_algorithm(&mut self, v: ::std::vec::Vec<ChallengeSignatureAlgorithm>)665 pub fn set_signature_algorithm(&mut self, v: ::std::vec::Vec<ChallengeSignatureAlgorithm>) { 666 self.signature_algorithm = v; 667 } 668 669 // Mutable pointer to the field. mut_signature_algorithm(&mut self) -> &mut ::std::vec::Vec<ChallengeSignatureAlgorithm>670 pub fn mut_signature_algorithm(&mut self) -> &mut ::std::vec::Vec<ChallengeSignatureAlgorithm> { 671 &mut self.signature_algorithm 672 } 673 674 // Take field take_signature_algorithm(&mut self) -> ::std::vec::Vec<ChallengeSignatureAlgorithm>675 pub fn take_signature_algorithm(&mut self) -> ::std::vec::Vec<ChallengeSignatureAlgorithm> { 676 ::std::mem::replace(&mut self.signature_algorithm, ::std::vec::Vec::new()) 677 } 678 } 679 680 impl ::protobuf::Message for ChallengePublicKeyInfo { is_initialized(&self) -> bool681 fn is_initialized(&self) -> bool { 682 true 683 } 684 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>685 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 686 while !is.eof()? { 687 let (field_number, wire_type) = is.read_tag_unpack()?; 688 match field_number { 689 1 => { 690 ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.public_key_spki_der)?; 691 }, 692 2 => { 693 ::protobuf::rt::read_repeated_enum_with_unknown_fields_into(wire_type, is, &mut self.signature_algorithm, 2, &mut self.unknown_fields)? 694 }, 695 _ => { 696 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 697 }, 698 }; 699 } 700 ::std::result::Result::Ok(()) 701 } 702 703 // Compute sizes of nested messages 704 #[allow(unused_variables)] compute_size(&self) -> u32705 fn compute_size(&self) -> u32 { 706 let mut my_size = 0; 707 if let Some(ref v) = self.public_key_spki_der.as_ref() { 708 my_size += ::protobuf::rt::bytes_size(1, &v); 709 } 710 for value in &self.signature_algorithm { 711 my_size += ::protobuf::rt::enum_size(2, *value); 712 }; 713 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 714 self.cached_size.set(my_size); 715 my_size 716 } 717 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>718 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 719 if let Some(ref v) = self.public_key_spki_der.as_ref() { 720 os.write_bytes(1, &v)?; 721 } 722 for v in &self.signature_algorithm { 723 os.write_enum(2, ::protobuf::ProtobufEnum::value(v))?; 724 }; 725 os.write_unknown_fields(self.get_unknown_fields())?; 726 ::std::result::Result::Ok(()) 727 } 728 get_cached_size(&self) -> u32729 fn get_cached_size(&self) -> u32 { 730 self.cached_size.get() 731 } 732 get_unknown_fields(&self) -> &::protobuf::UnknownFields733 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 734 &self.unknown_fields 735 } 736 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields737 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 738 &mut self.unknown_fields 739 } 740 as_any(&self) -> &dyn (::std::any::Any)741 fn as_any(&self) -> &dyn (::std::any::Any) { 742 self as &dyn (::std::any::Any) 743 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)744 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 745 self as &mut dyn (::std::any::Any) 746 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>747 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 748 self 749 } 750 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor751 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 752 Self::descriptor_static() 753 } 754 new() -> ChallengePublicKeyInfo755 fn new() -> ChallengePublicKeyInfo { 756 ChallengePublicKeyInfo::new() 757 } 758 default_instance() -> &'static ChallengePublicKeyInfo759 fn default_instance() -> &'static ChallengePublicKeyInfo { 760 static instance: ::protobuf::rt::LazyV2<ChallengePublicKeyInfo> = ::protobuf::rt::LazyV2::INIT; 761 instance.get(ChallengePublicKeyInfo::new) 762 } 763 } 764 765 impl ::protobuf::Clear for ChallengePublicKeyInfo { clear(&mut self)766 fn clear(&mut self) { 767 self.public_key_spki_der.clear(); 768 self.signature_algorithm.clear(); 769 self.unknown_fields.clear(); 770 } 771 } 772 773 impl ::protobuf::reflect::ProtobufValue for ChallengePublicKeyInfo { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef774 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 775 ::protobuf::reflect::ReflectValueRef::Message(self) 776 } 777 } 778 779 #[derive(PartialEq,Clone,Default,Debug)] 780 pub struct KeyPolicy { 781 // message fields 782 low_entropy_credential: ::std::option::Option<bool>, 783 auth_locked: ::std::option::Option<bool>, 784 // special fields 785 pub unknown_fields: ::protobuf::UnknownFields, 786 pub cached_size: ::protobuf::CachedSize, 787 } 788 789 impl<'a> ::std::default::Default for &'a KeyPolicy { default() -> &'a KeyPolicy790 fn default() -> &'a KeyPolicy { 791 <KeyPolicy as ::protobuf::Message>::default_instance() 792 } 793 } 794 795 impl KeyPolicy { new() -> KeyPolicy796 pub fn new() -> KeyPolicy { 797 ::std::default::Default::default() 798 } 799 800 // optional bool low_entropy_credential = 1; 801 802 get_low_entropy_credential(&self) -> bool803 pub fn get_low_entropy_credential(&self) -> bool { 804 self.low_entropy_credential.unwrap_or(false) 805 } clear_low_entropy_credential(&mut self)806 pub fn clear_low_entropy_credential(&mut self) { 807 self.low_entropy_credential = ::std::option::Option::None; 808 } 809 has_low_entropy_credential(&self) -> bool810 pub fn has_low_entropy_credential(&self) -> bool { 811 self.low_entropy_credential.is_some() 812 } 813 814 // Param is passed by value, moved set_low_entropy_credential(&mut self, v: bool)815 pub fn set_low_entropy_credential(&mut self, v: bool) { 816 self.low_entropy_credential = ::std::option::Option::Some(v); 817 } 818 819 // optional bool auth_locked = 2; 820 821 get_auth_locked(&self) -> bool822 pub fn get_auth_locked(&self) -> bool { 823 self.auth_locked.unwrap_or(false) 824 } clear_auth_locked(&mut self)825 pub fn clear_auth_locked(&mut self) { 826 self.auth_locked = ::std::option::Option::None; 827 } 828 has_auth_locked(&self) -> bool829 pub fn has_auth_locked(&self) -> bool { 830 self.auth_locked.is_some() 831 } 832 833 // Param is passed by value, moved set_auth_locked(&mut self, v: bool)834 pub fn set_auth_locked(&mut self, v: bool) { 835 self.auth_locked = ::std::option::Option::Some(v); 836 } 837 } 838 839 impl ::protobuf::Message for KeyPolicy { is_initialized(&self) -> bool840 fn is_initialized(&self) -> bool { 841 true 842 } 843 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>844 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 845 while !is.eof()? { 846 let (field_number, wire_type) = is.read_tag_unpack()?; 847 match field_number { 848 1 => { 849 if wire_type != ::protobuf::wire_format::WireTypeVarint { 850 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 851 } 852 let tmp = is.read_bool()?; 853 self.low_entropy_credential = ::std::option::Option::Some(tmp); 854 }, 855 2 => { 856 if wire_type != ::protobuf::wire_format::WireTypeVarint { 857 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 858 } 859 let tmp = is.read_bool()?; 860 self.auth_locked = ::std::option::Option::Some(tmp); 861 }, 862 _ => { 863 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 864 }, 865 }; 866 } 867 ::std::result::Result::Ok(()) 868 } 869 870 // Compute sizes of nested messages 871 #[allow(unused_variables)] compute_size(&self) -> u32872 fn compute_size(&self) -> u32 { 873 let mut my_size = 0; 874 if let Some(v) = self.low_entropy_credential { 875 my_size += 2; 876 } 877 if let Some(v) = self.auth_locked { 878 my_size += 2; 879 } 880 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 881 self.cached_size.set(my_size); 882 my_size 883 } 884 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>885 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 886 if let Some(v) = self.low_entropy_credential { 887 os.write_bool(1, v)?; 888 } 889 if let Some(v) = self.auth_locked { 890 os.write_bool(2, v)?; 891 } 892 os.write_unknown_fields(self.get_unknown_fields())?; 893 ::std::result::Result::Ok(()) 894 } 895 get_cached_size(&self) -> u32896 fn get_cached_size(&self) -> u32 { 897 self.cached_size.get() 898 } 899 get_unknown_fields(&self) -> &::protobuf::UnknownFields900 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 901 &self.unknown_fields 902 } 903 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields904 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 905 &mut self.unknown_fields 906 } 907 as_any(&self) -> &dyn (::std::any::Any)908 fn as_any(&self) -> &dyn (::std::any::Any) { 909 self as &dyn (::std::any::Any) 910 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)911 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 912 self as &mut dyn (::std::any::Any) 913 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>914 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 915 self 916 } 917 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor918 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 919 Self::descriptor_static() 920 } 921 new() -> KeyPolicy922 fn new() -> KeyPolicy { 923 KeyPolicy::new() 924 } 925 default_instance() -> &'static KeyPolicy926 fn default_instance() -> &'static KeyPolicy { 927 static instance: ::protobuf::rt::LazyV2<KeyPolicy> = ::protobuf::rt::LazyV2::INIT; 928 instance.get(KeyPolicy::new) 929 } 930 } 931 932 impl ::protobuf::Clear for KeyPolicy { clear(&mut self)933 fn clear(&mut self) { 934 self.low_entropy_credential = ::std::option::Option::None; 935 self.auth_locked = ::std::option::Option::None; 936 self.unknown_fields.clear(); 937 } 938 } 939 940 impl ::protobuf::reflect::ProtobufValue for KeyPolicy { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef941 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 942 ::protobuf::reflect::ReflectValueRef::Message(self) 943 } 944 } 945 946 #[derive(PartialEq,Clone,Default,Debug)] 947 pub struct KeyData { 948 // message fields 949 field_type: ::std::option::Option<KeyData_KeyType>, 950 label: ::protobuf::SingularField<::std::string::String>, 951 pub privileges: ::protobuf::SingularPtrField<KeyPrivileges>, 952 revision: ::std::option::Option<i64>, 953 pub provider_data: ::protobuf::SingularPtrField<KeyProviderData>, 954 pub challenge_response_key: ::protobuf::RepeatedField<ChallengePublicKeyInfo>, 955 pub policy: ::protobuf::SingularPtrField<KeyPolicy>, 956 // special fields 957 pub unknown_fields: ::protobuf::UnknownFields, 958 pub cached_size: ::protobuf::CachedSize, 959 } 960 961 impl<'a> ::std::default::Default for &'a KeyData { default() -> &'a KeyData962 fn default() -> &'a KeyData { 963 <KeyData as ::protobuf::Message>::default_instance() 964 } 965 } 966 967 impl KeyData { new() -> KeyData968 pub fn new() -> KeyData { 969 ::std::default::Default::default() 970 } 971 972 // optional .cryptohome.KeyData.KeyType type = 1; 973 974 get_field_type(&self) -> KeyData_KeyType975 pub fn get_field_type(&self) -> KeyData_KeyType { 976 self.field_type.unwrap_or(KeyData_KeyType::KEY_TYPE_PASSWORD) 977 } clear_field_type(&mut self)978 pub fn clear_field_type(&mut self) { 979 self.field_type = ::std::option::Option::None; 980 } 981 has_field_type(&self) -> bool982 pub fn has_field_type(&self) -> bool { 983 self.field_type.is_some() 984 } 985 986 // Param is passed by value, moved set_field_type(&mut self, v: KeyData_KeyType)987 pub fn set_field_type(&mut self, v: KeyData_KeyType) { 988 self.field_type = ::std::option::Option::Some(v); 989 } 990 991 // optional string label = 2; 992 993 get_label(&self) -> &str994 pub fn get_label(&self) -> &str { 995 match self.label.as_ref() { 996 Some(v) => &v, 997 None => "", 998 } 999 } clear_label(&mut self)1000 pub fn clear_label(&mut self) { 1001 self.label.clear(); 1002 } 1003 has_label(&self) -> bool1004 pub fn has_label(&self) -> bool { 1005 self.label.is_some() 1006 } 1007 1008 // Param is passed by value, moved set_label(&mut self, v: ::std::string::String)1009 pub fn set_label(&mut self, v: ::std::string::String) { 1010 self.label = ::protobuf::SingularField::some(v); 1011 } 1012 1013 // Mutable pointer to the field. 1014 // If field is not initialized, it is initialized with default value first. mut_label(&mut self) -> &mut ::std::string::String1015 pub fn mut_label(&mut self) -> &mut ::std::string::String { 1016 if self.label.is_none() { 1017 self.label.set_default(); 1018 } 1019 self.label.as_mut().unwrap() 1020 } 1021 1022 // Take field take_label(&mut self) -> ::std::string::String1023 pub fn take_label(&mut self) -> ::std::string::String { 1024 self.label.take().unwrap_or_else(|| ::std::string::String::new()) 1025 } 1026 1027 // optional .cryptohome.KeyPrivileges privileges = 3; 1028 1029 get_privileges(&self) -> &KeyPrivileges1030 pub fn get_privileges(&self) -> &KeyPrivileges { 1031 self.privileges.as_ref().unwrap_or_else(|| <KeyPrivileges as ::protobuf::Message>::default_instance()) 1032 } clear_privileges(&mut self)1033 pub fn clear_privileges(&mut self) { 1034 self.privileges.clear(); 1035 } 1036 has_privileges(&self) -> bool1037 pub fn has_privileges(&self) -> bool { 1038 self.privileges.is_some() 1039 } 1040 1041 // Param is passed by value, moved set_privileges(&mut self, v: KeyPrivileges)1042 pub fn set_privileges(&mut self, v: KeyPrivileges) { 1043 self.privileges = ::protobuf::SingularPtrField::some(v); 1044 } 1045 1046 // Mutable pointer to the field. 1047 // If field is not initialized, it is initialized with default value first. mut_privileges(&mut self) -> &mut KeyPrivileges1048 pub fn mut_privileges(&mut self) -> &mut KeyPrivileges { 1049 if self.privileges.is_none() { 1050 self.privileges.set_default(); 1051 } 1052 self.privileges.as_mut().unwrap() 1053 } 1054 1055 // Take field take_privileges(&mut self) -> KeyPrivileges1056 pub fn take_privileges(&mut self) -> KeyPrivileges { 1057 self.privileges.take().unwrap_or_else(|| KeyPrivileges::new()) 1058 } 1059 1060 // optional int64 revision = 4; 1061 1062 get_revision(&self) -> i641063 pub fn get_revision(&self) -> i64 { 1064 self.revision.unwrap_or(0) 1065 } clear_revision(&mut self)1066 pub fn clear_revision(&mut self) { 1067 self.revision = ::std::option::Option::None; 1068 } 1069 has_revision(&self) -> bool1070 pub fn has_revision(&self) -> bool { 1071 self.revision.is_some() 1072 } 1073 1074 // Param is passed by value, moved set_revision(&mut self, v: i64)1075 pub fn set_revision(&mut self, v: i64) { 1076 self.revision = ::std::option::Option::Some(v); 1077 } 1078 1079 // optional .cryptohome.KeyProviderData provider_data = 6; 1080 1081 get_provider_data(&self) -> &KeyProviderData1082 pub fn get_provider_data(&self) -> &KeyProviderData { 1083 self.provider_data.as_ref().unwrap_or_else(|| <KeyProviderData as ::protobuf::Message>::default_instance()) 1084 } clear_provider_data(&mut self)1085 pub fn clear_provider_data(&mut self) { 1086 self.provider_data.clear(); 1087 } 1088 has_provider_data(&self) -> bool1089 pub fn has_provider_data(&self) -> bool { 1090 self.provider_data.is_some() 1091 } 1092 1093 // Param is passed by value, moved set_provider_data(&mut self, v: KeyProviderData)1094 pub fn set_provider_data(&mut self, v: KeyProviderData) { 1095 self.provider_data = ::protobuf::SingularPtrField::some(v); 1096 } 1097 1098 // Mutable pointer to the field. 1099 // If field is not initialized, it is initialized with default value first. mut_provider_data(&mut self) -> &mut KeyProviderData1100 pub fn mut_provider_data(&mut self) -> &mut KeyProviderData { 1101 if self.provider_data.is_none() { 1102 self.provider_data.set_default(); 1103 } 1104 self.provider_data.as_mut().unwrap() 1105 } 1106 1107 // Take field take_provider_data(&mut self) -> KeyProviderData1108 pub fn take_provider_data(&mut self) -> KeyProviderData { 1109 self.provider_data.take().unwrap_or_else(|| KeyProviderData::new()) 1110 } 1111 1112 // repeated .cryptohome.ChallengePublicKeyInfo challenge_response_key = 7; 1113 1114 get_challenge_response_key(&self) -> &[ChallengePublicKeyInfo]1115 pub fn get_challenge_response_key(&self) -> &[ChallengePublicKeyInfo] { 1116 &self.challenge_response_key 1117 } clear_challenge_response_key(&mut self)1118 pub fn clear_challenge_response_key(&mut self) { 1119 self.challenge_response_key.clear(); 1120 } 1121 1122 // Param is passed by value, moved set_challenge_response_key(&mut self, v: ::protobuf::RepeatedField<ChallengePublicKeyInfo>)1123 pub fn set_challenge_response_key(&mut self, v: ::protobuf::RepeatedField<ChallengePublicKeyInfo>) { 1124 self.challenge_response_key = v; 1125 } 1126 1127 // Mutable pointer to the field. mut_challenge_response_key(&mut self) -> &mut ::protobuf::RepeatedField<ChallengePublicKeyInfo>1128 pub fn mut_challenge_response_key(&mut self) -> &mut ::protobuf::RepeatedField<ChallengePublicKeyInfo> { 1129 &mut self.challenge_response_key 1130 } 1131 1132 // Take field take_challenge_response_key(&mut self) -> ::protobuf::RepeatedField<ChallengePublicKeyInfo>1133 pub fn take_challenge_response_key(&mut self) -> ::protobuf::RepeatedField<ChallengePublicKeyInfo> { 1134 ::std::mem::replace(&mut self.challenge_response_key, ::protobuf::RepeatedField::new()) 1135 } 1136 1137 // optional .cryptohome.KeyPolicy policy = 8; 1138 1139 get_policy(&self) -> &KeyPolicy1140 pub fn get_policy(&self) -> &KeyPolicy { 1141 self.policy.as_ref().unwrap_or_else(|| <KeyPolicy as ::protobuf::Message>::default_instance()) 1142 } clear_policy(&mut self)1143 pub fn clear_policy(&mut self) { 1144 self.policy.clear(); 1145 } 1146 has_policy(&self) -> bool1147 pub fn has_policy(&self) -> bool { 1148 self.policy.is_some() 1149 } 1150 1151 // Param is passed by value, moved set_policy(&mut self, v: KeyPolicy)1152 pub fn set_policy(&mut self, v: KeyPolicy) { 1153 self.policy = ::protobuf::SingularPtrField::some(v); 1154 } 1155 1156 // Mutable pointer to the field. 1157 // If field is not initialized, it is initialized with default value first. mut_policy(&mut self) -> &mut KeyPolicy1158 pub fn mut_policy(&mut self) -> &mut KeyPolicy { 1159 if self.policy.is_none() { 1160 self.policy.set_default(); 1161 } 1162 self.policy.as_mut().unwrap() 1163 } 1164 1165 // Take field take_policy(&mut self) -> KeyPolicy1166 pub fn take_policy(&mut self) -> KeyPolicy { 1167 self.policy.take().unwrap_or_else(|| KeyPolicy::new()) 1168 } 1169 } 1170 1171 impl ::protobuf::Message for KeyData { is_initialized(&self) -> bool1172 fn is_initialized(&self) -> bool { 1173 for v in &self.privileges { 1174 if !v.is_initialized() { 1175 return false; 1176 } 1177 }; 1178 for v in &self.provider_data { 1179 if !v.is_initialized() { 1180 return false; 1181 } 1182 }; 1183 for v in &self.challenge_response_key { 1184 if !v.is_initialized() { 1185 return false; 1186 } 1187 }; 1188 for v in &self.policy { 1189 if !v.is_initialized() { 1190 return false; 1191 } 1192 }; 1193 true 1194 } 1195 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>1196 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 1197 while !is.eof()? { 1198 let (field_number, wire_type) = is.read_tag_unpack()?; 1199 match field_number { 1200 1 => { 1201 ::protobuf::rt::read_proto2_enum_with_unknown_fields_into(wire_type, is, &mut self.field_type, 1, &mut self.unknown_fields)? 1202 }, 1203 2 => { 1204 ::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.label)?; 1205 }, 1206 3 => { 1207 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.privileges)?; 1208 }, 1209 4 => { 1210 if wire_type != ::protobuf::wire_format::WireTypeVarint { 1211 return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); 1212 } 1213 let tmp = is.read_int64()?; 1214 self.revision = ::std::option::Option::Some(tmp); 1215 }, 1216 6 => { 1217 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.provider_data)?; 1218 }, 1219 7 => { 1220 ::protobuf::rt::read_repeated_message_into(wire_type, is, &mut self.challenge_response_key)?; 1221 }, 1222 8 => { 1223 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.policy)?; 1224 }, 1225 _ => { 1226 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 1227 }, 1228 }; 1229 } 1230 ::std::result::Result::Ok(()) 1231 } 1232 1233 // Compute sizes of nested messages 1234 #[allow(unused_variables)] compute_size(&self) -> u321235 fn compute_size(&self) -> u32 { 1236 let mut my_size = 0; 1237 if let Some(v) = self.field_type { 1238 my_size += ::protobuf::rt::enum_size(1, v); 1239 } 1240 if let Some(ref v) = self.label.as_ref() { 1241 my_size += ::protobuf::rt::string_size(2, &v); 1242 } 1243 if let Some(ref v) = self.privileges.as_ref() { 1244 let len = v.compute_size(); 1245 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; 1246 } 1247 if let Some(v) = self.revision { 1248 my_size += ::protobuf::rt::value_size(4, v, ::protobuf::wire_format::WireTypeVarint); 1249 } 1250 if let Some(ref v) = self.provider_data.as_ref() { 1251 let len = v.compute_size(); 1252 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; 1253 } 1254 for value in &self.challenge_response_key { 1255 let len = value.compute_size(); 1256 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; 1257 }; 1258 if let Some(ref v) = self.policy.as_ref() { 1259 let len = v.compute_size(); 1260 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; 1261 } 1262 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 1263 self.cached_size.set(my_size); 1264 my_size 1265 } 1266 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>1267 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 1268 if let Some(v) = self.field_type { 1269 os.write_enum(1, ::protobuf::ProtobufEnum::value(&v))?; 1270 } 1271 if let Some(ref v) = self.label.as_ref() { 1272 os.write_string(2, &v)?; 1273 } 1274 if let Some(ref v) = self.privileges.as_ref() { 1275 os.write_tag(3, ::protobuf::wire_format::WireTypeLengthDelimited)?; 1276 os.write_raw_varint32(v.get_cached_size())?; 1277 v.write_to_with_cached_sizes(os)?; 1278 } 1279 if let Some(v) = self.revision { 1280 os.write_int64(4, v)?; 1281 } 1282 if let Some(ref v) = self.provider_data.as_ref() { 1283 os.write_tag(6, ::protobuf::wire_format::WireTypeLengthDelimited)?; 1284 os.write_raw_varint32(v.get_cached_size())?; 1285 v.write_to_with_cached_sizes(os)?; 1286 } 1287 for v in &self.challenge_response_key { 1288 os.write_tag(7, ::protobuf::wire_format::WireTypeLengthDelimited)?; 1289 os.write_raw_varint32(v.get_cached_size())?; 1290 v.write_to_with_cached_sizes(os)?; 1291 }; 1292 if let Some(ref v) = self.policy.as_ref() { 1293 os.write_tag(8, ::protobuf::wire_format::WireTypeLengthDelimited)?; 1294 os.write_raw_varint32(v.get_cached_size())?; 1295 v.write_to_with_cached_sizes(os)?; 1296 } 1297 os.write_unknown_fields(self.get_unknown_fields())?; 1298 ::std::result::Result::Ok(()) 1299 } 1300 get_cached_size(&self) -> u321301 fn get_cached_size(&self) -> u32 { 1302 self.cached_size.get() 1303 } 1304 get_unknown_fields(&self) -> &::protobuf::UnknownFields1305 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 1306 &self.unknown_fields 1307 } 1308 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields1309 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 1310 &mut self.unknown_fields 1311 } 1312 as_any(&self) -> &dyn (::std::any::Any)1313 fn as_any(&self) -> &dyn (::std::any::Any) { 1314 self as &dyn (::std::any::Any) 1315 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)1316 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 1317 self as &mut dyn (::std::any::Any) 1318 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>1319 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 1320 self 1321 } 1322 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor1323 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 1324 Self::descriptor_static() 1325 } 1326 new() -> KeyData1327 fn new() -> KeyData { 1328 KeyData::new() 1329 } 1330 default_instance() -> &'static KeyData1331 fn default_instance() -> &'static KeyData { 1332 static instance: ::protobuf::rt::LazyV2<KeyData> = ::protobuf::rt::LazyV2::INIT; 1333 instance.get(KeyData::new) 1334 } 1335 } 1336 1337 impl ::protobuf::Clear for KeyData { clear(&mut self)1338 fn clear(&mut self) { 1339 self.field_type = ::std::option::Option::None; 1340 self.label.clear(); 1341 self.privileges.clear(); 1342 self.revision = ::std::option::Option::None; 1343 self.provider_data.clear(); 1344 self.challenge_response_key.clear(); 1345 self.policy.clear(); 1346 self.unknown_fields.clear(); 1347 } 1348 } 1349 1350 impl ::protobuf::reflect::ProtobufValue for KeyData { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef1351 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 1352 ::protobuf::reflect::ReflectValueRef::Message(self) 1353 } 1354 } 1355 1356 #[derive(Clone,PartialEq,Eq,Debug,Hash)] 1357 pub enum KeyData_KeyType { 1358 KEY_TYPE_PASSWORD = 0, 1359 KEY_TYPE_CHALLENGE_RESPONSE = 1, 1360 KEY_TYPE_FINGERPRINT = 2, 1361 KEY_TYPE_KIOSK = 3, 1362 } 1363 1364 impl ::protobuf::ProtobufEnum for KeyData_KeyType { value(&self) -> i321365 fn value(&self) -> i32 { 1366 *self as i32 1367 } 1368 from_i32(value: i32) -> ::std::option::Option<KeyData_KeyType>1369 fn from_i32(value: i32) -> ::std::option::Option<KeyData_KeyType> { 1370 match value { 1371 0 => ::std::option::Option::Some(KeyData_KeyType::KEY_TYPE_PASSWORD), 1372 1 => ::std::option::Option::Some(KeyData_KeyType::KEY_TYPE_CHALLENGE_RESPONSE), 1373 2 => ::std::option::Option::Some(KeyData_KeyType::KEY_TYPE_FINGERPRINT), 1374 3 => ::std::option::Option::Some(KeyData_KeyType::KEY_TYPE_KIOSK), 1375 _ => ::std::option::Option::None 1376 } 1377 } 1378 values() -> &'static [Self]1379 fn values() -> &'static [Self] { 1380 static values: &'static [KeyData_KeyType] = &[ 1381 KeyData_KeyType::KEY_TYPE_PASSWORD, 1382 KeyData_KeyType::KEY_TYPE_CHALLENGE_RESPONSE, 1383 KeyData_KeyType::KEY_TYPE_FINGERPRINT, 1384 KeyData_KeyType::KEY_TYPE_KIOSK, 1385 ]; 1386 values 1387 } 1388 } 1389 1390 impl ::std::marker::Copy for KeyData_KeyType { 1391 } 1392 1393 impl ::std::default::Default for KeyData_KeyType { default() -> Self1394 fn default() -> Self { 1395 KeyData_KeyType::KEY_TYPE_PASSWORD 1396 } 1397 } 1398 1399 impl ::protobuf::reflect::ProtobufValue for KeyData_KeyType { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef1400 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 1401 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self)) 1402 } 1403 } 1404 1405 #[derive(PartialEq,Clone,Default,Debug)] 1406 pub struct Key { 1407 // message fields 1408 pub data: ::protobuf::SingularPtrField<KeyData>, 1409 secret: ::protobuf::SingularField<::std::vec::Vec<u8>>, 1410 // special fields 1411 pub unknown_fields: ::protobuf::UnknownFields, 1412 pub cached_size: ::protobuf::CachedSize, 1413 } 1414 1415 impl<'a> ::std::default::Default for &'a Key { default() -> &'a Key1416 fn default() -> &'a Key { 1417 <Key as ::protobuf::Message>::default_instance() 1418 } 1419 } 1420 1421 impl Key { new() -> Key1422 pub fn new() -> Key { 1423 ::std::default::Default::default() 1424 } 1425 1426 // optional .cryptohome.KeyData data = 1; 1427 1428 get_data(&self) -> &KeyData1429 pub fn get_data(&self) -> &KeyData { 1430 self.data.as_ref().unwrap_or_else(|| <KeyData as ::protobuf::Message>::default_instance()) 1431 } clear_data(&mut self)1432 pub fn clear_data(&mut self) { 1433 self.data.clear(); 1434 } 1435 has_data(&self) -> bool1436 pub fn has_data(&self) -> bool { 1437 self.data.is_some() 1438 } 1439 1440 // Param is passed by value, moved set_data(&mut self, v: KeyData)1441 pub fn set_data(&mut self, v: KeyData) { 1442 self.data = ::protobuf::SingularPtrField::some(v); 1443 } 1444 1445 // Mutable pointer to the field. 1446 // If field is not initialized, it is initialized with default value first. mut_data(&mut self) -> &mut KeyData1447 pub fn mut_data(&mut self) -> &mut KeyData { 1448 if self.data.is_none() { 1449 self.data.set_default(); 1450 } 1451 self.data.as_mut().unwrap() 1452 } 1453 1454 // Take field take_data(&mut self) -> KeyData1455 pub fn take_data(&mut self) -> KeyData { 1456 self.data.take().unwrap_or_else(|| KeyData::new()) 1457 } 1458 1459 // optional bytes secret = 2; 1460 1461 get_secret(&self) -> &[u8]1462 pub fn get_secret(&self) -> &[u8] { 1463 match self.secret.as_ref() { 1464 Some(v) => &v, 1465 None => &[], 1466 } 1467 } clear_secret(&mut self)1468 pub fn clear_secret(&mut self) { 1469 self.secret.clear(); 1470 } 1471 has_secret(&self) -> bool1472 pub fn has_secret(&self) -> bool { 1473 self.secret.is_some() 1474 } 1475 1476 // Param is passed by value, moved set_secret(&mut self, v: ::std::vec::Vec<u8>)1477 pub fn set_secret(&mut self, v: ::std::vec::Vec<u8>) { 1478 self.secret = ::protobuf::SingularField::some(v); 1479 } 1480 1481 // Mutable pointer to the field. 1482 // If field is not initialized, it is initialized with default value first. mut_secret(&mut self) -> &mut ::std::vec::Vec<u8>1483 pub fn mut_secret(&mut self) -> &mut ::std::vec::Vec<u8> { 1484 if self.secret.is_none() { 1485 self.secret.set_default(); 1486 } 1487 self.secret.as_mut().unwrap() 1488 } 1489 1490 // Take field take_secret(&mut self) -> ::std::vec::Vec<u8>1491 pub fn take_secret(&mut self) -> ::std::vec::Vec<u8> { 1492 self.secret.take().unwrap_or_else(|| ::std::vec::Vec::new()) 1493 } 1494 } 1495 1496 impl ::protobuf::Message for Key { is_initialized(&self) -> bool1497 fn is_initialized(&self) -> bool { 1498 for v in &self.data { 1499 if !v.is_initialized() { 1500 return false; 1501 } 1502 }; 1503 true 1504 } 1505 merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()>1506 fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> { 1507 while !is.eof()? { 1508 let (field_number, wire_type) = is.read_tag_unpack()?; 1509 match field_number { 1510 1 => { 1511 ::protobuf::rt::read_singular_message_into(wire_type, is, &mut self.data)?; 1512 }, 1513 2 => { 1514 ::protobuf::rt::read_singular_bytes_into(wire_type, is, &mut self.secret)?; 1515 }, 1516 _ => { 1517 ::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?; 1518 }, 1519 }; 1520 } 1521 ::std::result::Result::Ok(()) 1522 } 1523 1524 // Compute sizes of nested messages 1525 #[allow(unused_variables)] compute_size(&self) -> u321526 fn compute_size(&self) -> u32 { 1527 let mut my_size = 0; 1528 if let Some(ref v) = self.data.as_ref() { 1529 let len = v.compute_size(); 1530 my_size += 1 + ::protobuf::rt::compute_raw_varint32_size(len) + len; 1531 } 1532 if let Some(ref v) = self.secret.as_ref() { 1533 my_size += ::protobuf::rt::bytes_size(2, &v); 1534 } 1535 my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); 1536 self.cached_size.set(my_size); 1537 my_size 1538 } 1539 write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()>1540 fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> { 1541 if let Some(ref v) = self.data.as_ref() { 1542 os.write_tag(1, ::protobuf::wire_format::WireTypeLengthDelimited)?; 1543 os.write_raw_varint32(v.get_cached_size())?; 1544 v.write_to_with_cached_sizes(os)?; 1545 } 1546 if let Some(ref v) = self.secret.as_ref() { 1547 os.write_bytes(2, &v)?; 1548 } 1549 os.write_unknown_fields(self.get_unknown_fields())?; 1550 ::std::result::Result::Ok(()) 1551 } 1552 get_cached_size(&self) -> u321553 fn get_cached_size(&self) -> u32 { 1554 self.cached_size.get() 1555 } 1556 get_unknown_fields(&self) -> &::protobuf::UnknownFields1557 fn get_unknown_fields(&self) -> &::protobuf::UnknownFields { 1558 &self.unknown_fields 1559 } 1560 mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields1561 fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields { 1562 &mut self.unknown_fields 1563 } 1564 as_any(&self) -> &dyn (::std::any::Any)1565 fn as_any(&self) -> &dyn (::std::any::Any) { 1566 self as &dyn (::std::any::Any) 1567 } as_any_mut(&mut self) -> &mut dyn (::std::any::Any)1568 fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) { 1569 self as &mut dyn (::std::any::Any) 1570 } into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)>1571 fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> { 1572 self 1573 } 1574 descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor1575 fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { 1576 Self::descriptor_static() 1577 } 1578 new() -> Key1579 fn new() -> Key { 1580 Key::new() 1581 } 1582 default_instance() -> &'static Key1583 fn default_instance() -> &'static Key { 1584 static instance: ::protobuf::rt::LazyV2<Key> = ::protobuf::rt::LazyV2::INIT; 1585 instance.get(Key::new) 1586 } 1587 } 1588 1589 impl ::protobuf::Clear for Key { clear(&mut self)1590 fn clear(&mut self) { 1591 self.data.clear(); 1592 self.secret.clear(); 1593 self.unknown_fields.clear(); 1594 } 1595 } 1596 1597 impl ::protobuf::reflect::ProtobufValue for Key { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef1598 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 1599 ::protobuf::reflect::ReflectValueRef::Message(self) 1600 } 1601 } 1602 1603 #[derive(Clone,PartialEq,Eq,Debug,Hash)] 1604 pub enum ChallengeSignatureAlgorithm { 1605 CHALLENGE_RSASSA_PKCS1_V1_5_SHA1 = 1, 1606 CHALLENGE_RSASSA_PKCS1_V1_5_SHA256 = 2, 1607 CHALLENGE_RSASSA_PKCS1_V1_5_SHA384 = 3, 1608 CHALLENGE_RSASSA_PKCS1_V1_5_SHA512 = 4, 1609 } 1610 1611 impl ::protobuf::ProtobufEnum for ChallengeSignatureAlgorithm { value(&self) -> i321612 fn value(&self) -> i32 { 1613 *self as i32 1614 } 1615 from_i32(value: i32) -> ::std::option::Option<ChallengeSignatureAlgorithm>1616 fn from_i32(value: i32) -> ::std::option::Option<ChallengeSignatureAlgorithm> { 1617 match value { 1618 1 => ::std::option::Option::Some(ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA1), 1619 2 => ::std::option::Option::Some(ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA256), 1620 3 => ::std::option::Option::Some(ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA384), 1621 4 => ::std::option::Option::Some(ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA512), 1622 _ => ::std::option::Option::None 1623 } 1624 } 1625 values() -> &'static [Self]1626 fn values() -> &'static [Self] { 1627 static values: &'static [ChallengeSignatureAlgorithm] = &[ 1628 ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA1, 1629 ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA256, 1630 ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA384, 1631 ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA512, 1632 ]; 1633 values 1634 } 1635 } 1636 1637 impl ::std::marker::Copy for ChallengeSignatureAlgorithm { 1638 } 1639 1640 // Note, `Default` is implemented although default value is not 0 1641 impl ::std::default::Default for ChallengeSignatureAlgorithm { default() -> Self1642 fn default() -> Self { 1643 ChallengeSignatureAlgorithm::CHALLENGE_RSASSA_PKCS1_V1_5_SHA1 1644 } 1645 } 1646 1647 impl ::protobuf::reflect::ProtobufValue for ChallengeSignatureAlgorithm { as_ref(&self) -> ::protobuf::reflect::ReflectValueRef1648 fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef { 1649 ::protobuf::reflect::ReflectValueRef::Enum(::protobuf::ProtobufEnum::descriptor(self)) 1650 } 1651 } 1652