// 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(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(Clone,Default)] pub struct Subscription { // message fields uri: ::protobuf::SingularField<::std::string::String>, expiry: ::std::option::Option, status_code: ::std::option::Option, // special fields unknown_fields: ::protobuf::UnknownFields, cached_size: ::std::cell::Cell, } // see codegen.rs for the explanation why impl Sync explicitly unsafe impl ::std::marker::Sync for Subscription {} impl Subscription { pub fn new() -> Subscription { ::std::default::Default::default() } pub fn default_instance() -> &'static Subscription { static mut instance: ::protobuf::lazy::Lazy = ::protobuf::lazy::Lazy { lock: ::protobuf::lazy::ONCE_INIT, ptr: 0 as *const Subscription, }; unsafe { instance.get(|| { Subscription { uri: ::protobuf::SingularField::none(), expiry: ::std::option::Option::None, status_code: ::std::option::Option::None, unknown_fields: ::protobuf::UnknownFields::new(), cached_size: ::std::cell::Cell::new(0), } }) } } // optional string uri = 1; pub fn clear_uri(&mut self) { self.uri.clear(); } pub fn has_uri(&self) -> bool { self.uri.is_some() } // Param is passed by value, moved pub fn set_uri(&mut self, v: ::std::string::String) { self.uri = ::protobuf::SingularField::some(v); } // Mutable pointer to the field. // If field is not initialized, it is initialized with default value first. pub fn mut_uri(&mut self) -> &mut ::std::string::String { if self.uri.is_none() { self.uri.set_default(); }; self.uri.as_mut().unwrap() } // Take field pub fn take_uri(&mut self) -> ::std::string::String { self.uri.take().unwrap_or_else(|| ::std::string::String::new()) } pub fn get_uri(&self) -> &str { match self.uri.as_ref() { Some(v) => &v, None => "", } } // optional int32 expiry = 2; pub fn clear_expiry(&mut self) { self.expiry = ::std::option::Option::None; } pub fn has_expiry(&self) -> bool { self.expiry.is_some() } // Param is passed by value, moved pub fn set_expiry(&mut self, v: i32) { self.expiry = ::std::option::Option::Some(v); } pub fn get_expiry(&self) -> i32 { self.expiry.unwrap_or(0) } // optional int32 status_code = 3; pub fn clear_status_code(&mut self) { self.status_code = ::std::option::Option::None; } pub fn has_status_code(&self) -> bool { self.status_code.is_some() } // Param is passed by value, moved pub fn set_status_code(&mut self, v: i32) { self.status_code = ::std::option::Option::Some(v); } pub fn get_status_code(&self) -> i32 { self.status_code.unwrap_or(0) } } impl ::protobuf::Message for Subscription { fn is_initialized(&self) -> bool { true } fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream) -> ::protobuf::ProtobufResult<()> { while !try!(is.eof()) { let (field_number, wire_type) = try!(is.read_tag_unpack()); match field_number { 1 => { try!(::protobuf::rt::read_singular_string_into(wire_type, is, &mut self.uri)); }, 2 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); }; let tmp = try!(is.read_int32()); self.expiry = ::std::option::Option::Some(tmp); }, 3 => { if wire_type != ::protobuf::wire_format::WireTypeVarint { return ::std::result::Result::Err(::protobuf::rt::unexpected_wire_type(wire_type)); }; let tmp = try!(is.read_int32()); self.status_code = ::std::option::Option::Some(tmp); }, _ => { try!(::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; for value in &self.uri { my_size += ::protobuf::rt::string_size(1, &value); }; for value in &self.expiry { my_size += ::protobuf::rt::value_size(2, *value, ::protobuf::wire_format::WireTypeVarint); }; for value in &self.status_code { my_size += ::protobuf::rt::value_size(3, *value, ::protobuf::wire_format::WireTypeVarint); }; my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields()); self.cached_size.set(my_size); my_size } fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream) -> ::protobuf::ProtobufResult<()> { if let Some(v) = self.uri.as_ref() { try!(os.write_string(1, &v)); }; if let Some(v) = self.expiry { try!(os.write_int32(2, v)); }; if let Some(v) = self.status_code { try!(os.write_int32(3, v)); }; try!(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 type_id(&self) -> ::std::any::TypeId { ::std::any::TypeId::of::() } fn as_any(&self) -> &::std::any::Any { self as &::std::any::Any } fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor { ::protobuf::MessageStatic::descriptor_static(None::) } } impl ::protobuf::MessageStatic for Subscription { fn new() -> Subscription { Subscription::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_string_accessor( "uri", Subscription::has_uri, Subscription::get_uri, )); fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( "expiry", Subscription::has_expiry, Subscription::get_expiry, )); fields.push(::protobuf::reflect::accessor::make_singular_i32_accessor( "status_code", Subscription::has_status_code, Subscription::get_status_code, )); ::protobuf::reflect::MessageDescriptor::new::( "Subscription", fields, file_descriptor_proto() ) }) } } } impl ::protobuf::Clear for Subscription { fn clear(&mut self) { self.clear_uri(); self.clear_expiry(); self.clear_status_code(); self.unknown_fields.clear(); } } impl ::std::cmp::PartialEq for Subscription { fn eq(&self, other: &Subscription) -> bool { self.uri == other.uri && self.expiry == other.expiry && self.status_code == other.status_code && self.unknown_fields == other.unknown_fields } } impl ::std::fmt::Debug for Subscription { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { ::protobuf::text_format::fmt(self, f) } } static file_descriptor_proto_data: &'static [u8] = &[ 0x0a, 0x0c, 0x70, 0x75, 0x62, 0x73, 0x75, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x59, 0x0a, 0x0c, 0x53, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x12, 0x16, 0x0a, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, 0x65, 0x78, 0x70, 0x69, 0x72, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x5f, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x4a, 0xf9, 0x01, 0x0a, 0x06, 0x12, 0x04, 0x00, 0x00, 0x06, 0x01, 0x0a, 0x08, 0x0a, 0x01, 0x0c, 0x12, 0x03, 0x00, 0x00, 0x12, 0x0a, 0x0a, 0x0a, 0x02, 0x04, 0x00, 0x12, 0x04, 0x02, 0x00, 0x06, 0x01, 0x0a, 0x0a, 0x0a, 0x03, 0x04, 0x00, 0x01, 0x12, 0x03, 0x02, 0x08, 0x14, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x00, 0x12, 0x03, 0x03, 0x04, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x04, 0x12, 0x03, 0x03, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x05, 0x12, 0x03, 0x03, 0x0d, 0x13, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x01, 0x12, 0x03, 0x03, 0x14, 0x17, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x00, 0x03, 0x12, 0x03, 0x03, 0x1a, 0x1d, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x01, 0x12, 0x03, 0x04, 0x04, 0x20, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x04, 0x12, 0x03, 0x04, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x05, 0x12, 0x03, 0x04, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x01, 0x12, 0x03, 0x04, 0x13, 0x19, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x01, 0x03, 0x12, 0x03, 0x04, 0x1c, 0x1f, 0x0a, 0x0b, 0x0a, 0x04, 0x04, 0x00, 0x02, 0x02, 0x12, 0x03, 0x05, 0x04, 0x25, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x04, 0x12, 0x03, 0x05, 0x04, 0x0c, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x05, 0x12, 0x03, 0x05, 0x0d, 0x12, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x01, 0x12, 0x03, 0x05, 0x13, 0x1e, 0x0a, 0x0c, 0x0a, 0x05, 0x04, 0x00, 0x02, 0x02, 0x03, 0x12, 0x03, 0x05, 0x21, 0x24, ]; 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() }) } }