Struct google_api_proto::google::maps::addressvalidation::v1::AddressComponent

pub struct AddressComponent {
    pub component_name: Option<ComponentName>,
    pub component_type: String,
    pub confirmation_level: i32,
    pub inferred: bool,
    pub spell_corrected: bool,
    pub replaced: bool,
    pub unexpected: bool,
}

Represents an address component, such as a street, city, or state.

Fields

component_name: Option<ComponentName>

The name for this component.

component_type: String

The type of the address component. See Table 2: Additional types returned by the Places service for a list of possible types.

confirmation_level: i32

Indicates the level of certainty that we have that the component is correct.

inferred: bool

Indicates that the component was not part of the input, but we inferred it for the address location and believe it should be provided for a complete address.

spell_corrected: bool

Indicates a correction to a misspelling in the component name. The API does not always flag changes from one spelling variant to another, such as when changing “centre” to “center”. It also does not always flag common misspellings, such as when changing “Amphitheater Pkwy” to “Amphitheatre Pkwy”.

replaced: bool

Indicates the name of the component was replaced with a completely different one, for example a wrong postal code being replaced with one that is correct for the address. This is not a cosmetic change, the input component has been changed to a different one.

unexpected: bool

Indicates an address component that is not expected to be present in a postal address for the given region. We have retained it only because it was part of the input.

Implementations

impl AddressComponent

pub fn confirmation_level(&self) -> ConfirmationLevel

Returns the enum value of confirmation_level, or the default if the field is set to an invalid enum value.

pub fn set_confirmation_level(&mut self, value: ConfirmationLevel)

Sets confirmation_level to the provided enum value.

Trait Implementations

impl Clone for AddressComponent

fn clone(&self) -> AddressComponent

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AddressComponent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AddressComponent

fn default() -> Self

Returns the “default value” for a type.

impl Message for AddressComponent

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited<B>(&self, buf: &mut B) -> Result<(), EncodeError>

where B: BufMut, Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited<B>(buf: B) -> Result<Self, DecodeError>

where B: Buf, Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited<B>(&mut self, buf: B) -> Result<(), DecodeError>

where B: Buf, Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for AddressComponent

fn eq(&self, other: &AddressComponent) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for AddressComponent