Struct Address 

pub struct Address {
    pub formatted_address: String,
    pub postal_address: PostalAddress,
    pub address_components: Vec<AddressComponent>,
    pub missing_component_types: Vec<String>,
    pub unconfirmed_component_types: Vec<String>,
    pub unresolved_tokens: Vec<String>,
}

Details of the post-processed address. Post-processing includes correcting misspelled parts of the address, replacing incorrect parts, and inferring missing parts.

The address property provides formatting for the processed address provided in the request, along with component-level summaries of the address, including misspelled parts of the address, replaced incorrect parts, and inferred missing parts.

Fields

formatted_address: String

The post-processed address, formatted as a single-line address following the address formatting rules of the region where the address is located.

Note: the format of this address may not match the format of the address in the postalAddress field. For example, the postalAddress always represents the country as a 2 letter regionCode, such as “US” or “NZ”. By contrast, this field uses a longer form of the country name, such as “USA” or “New Zealand”.

postal_address: PostalAddress

The post-processed address represented as a postal address.

address_components: Vec<AddressComponent>

Unordered list. The individual address components of the formatted and corrected address, along with validation information. This provides information on the validation status of the individual components.

Address components are not ordered in a particular way. Do not make any assumptions on the ordering of the address components in the list.

missing_component_types: Vec<String>

The types of components that were expected to be present in a correctly formatted mailing address but were not found in the input AND could not be inferred. Components of this type are not present in formattedAddress, postalAddress, or addressComponents. An example might be ['street_number', 'route'] for an input like “Boulder, Colorado, 80301, USA”. The list of possible types can be found here.

unconfirmed_component_types: Vec<String>

The types of the components that are present in the addressComponents but could not be confirmed to be correct. This field is provided for the sake of convenience: its contents are equivalent to iterating through the addressComponents to find the types of all the components where the confirmationLevel is not CONFIRMED or the inferred flag is not set to true. The list of possible types can be found here.

unresolved_tokens: Vec<String>

Any tokens in the input that could not be resolved. This might be an input that was not recognized as a valid part of an address. For example, for an input such as “Parcel 0000123123 & 0000456456 Str # Guthrie Center IA 50115 US”, the unresolved tokens might look like ["Parcel", "0000123123", "&", "0000456456"].

Implementations

impl Address

pub fn formatted_address(&self) -> &String

The post-processed address, formatted as a single-line address following the address formatting rules of the region where the address is located.

Note: the format of this address may not match the format of the address in the postalAddress field. For example, the postalAddress always represents the country as a 2 letter regionCode, such as “US” or “NZ”. By contrast, this field uses a longer form of the country name, such as “USA” or “New Zealand”.

pub fn postal_address(&self) -> &PostalAddress

The post-processed address represented as a postal address.

pub fn address_components(&self) -> &Vec<AddressComponent>

Unordered list. The individual address components of the formatted and corrected address, along with validation information. This provides information on the validation status of the individual components.

Address components are not ordered in a particular way. Do not make any assumptions on the ordering of the address components in the list.

pub fn missing_component_types(&self) -> &Vec<String>

The types of components that were expected to be present in a correctly formatted mailing address but were not found in the input AND could not be inferred. Components of this type are not present in formattedAddress, postalAddress, or addressComponents. An example might be ['street_number', 'route'] for an input like “Boulder, Colorado, 80301, USA”. The list of possible types can be found here.

pub fn unconfirmed_component_types(&self) -> &Vec<String>

The types of the components that are present in the addressComponents but could not be confirmed to be correct. This field is provided for the sake of convenience: its contents are equivalent to iterating through the addressComponents to find the types of all the components where the confirmationLevel is not CONFIRMED or the inferred flag is not set to true. The list of possible types can be found here.

pub fn unresolved_tokens(&self) -> &Vec<String>

Any tokens in the input that could not be resolved. This might be an input that was not recognized as a valid part of an address. For example, for an input such as “Parcel 0000123123 & 0000456456 Str # Guthrie Center IA 50115 US”, the unresolved tokens might look like ["Parcel", "0000123123", "&", "0000456456"].

impl Address

pub fn formatted_address_mut(&mut self) -> &mut String

The post-processed address, formatted as a single-line address following the address formatting rules of the region where the address is located.

Note: the format of this address may not match the format of the address in the postalAddress field. For example, the postalAddress always represents the country as a 2 letter regionCode, such as “US” or “NZ”. By contrast, this field uses a longer form of the country name, such as “USA” or “New Zealand”.

pub fn postal_address_mut(&mut self) -> &mut PostalAddress

The post-processed address represented as a postal address.

pub fn address_components_mut(&mut self) -> &mut Vec<AddressComponent>

Unordered list. The individual address components of the formatted and corrected address, along with validation information. This provides information on the validation status of the individual components.

Address components are not ordered in a particular way. Do not make any assumptions on the ordering of the address components in the list.

pub fn missing_component_types_mut(&mut self) -> &mut Vec<String>

The types of components that were expected to be present in a correctly formatted mailing address but were not found in the input AND could not be inferred. Components of this type are not present in formattedAddress, postalAddress, or addressComponents. An example might be ['street_number', 'route'] for an input like “Boulder, Colorado, 80301, USA”. The list of possible types can be found here.

pub fn unconfirmed_component_types_mut(&mut self) -> &mut Vec<String>

The types of the components that are present in the addressComponents but could not be confirmed to be correct. This field is provided for the sake of convenience: its contents are equivalent to iterating through the addressComponents to find the types of all the components where the confirmationLevel is not CONFIRMED or the inferred flag is not set to true. The list of possible types can be found here.

pub fn unresolved_tokens_mut(&mut self) -> &mut Vec<String>

Any tokens in the input that could not be resolved. This might be an input that was not recognized as a valid part of an address. For example, for an input such as “Parcel 0000123123 & 0000456456 Str # Guthrie Center IA 50115 US”, the unresolved tokens might look like ["Parcel", "0000123123", "&", "0000456456"].

impl Address

pub fn set_formatted_address(&mut self, val: String) -> &mut Self

The post-processed address, formatted as a single-line address following the address formatting rules of the region where the address is located.

Note: the format of this address may not match the format of the address in the postalAddress field. For example, the postalAddress always represents the country as a 2 letter regionCode, such as “US” or “NZ”. By contrast, this field uses a longer form of the country name, such as “USA” or “New Zealand”.

pub fn set_postal_address(&mut self, val: PostalAddress) -> &mut Self

The post-processed address represented as a postal address.

pub fn set_address_components( &mut self, val: Vec<AddressComponent>, ) -> &mut Self

Unordered list. The individual address components of the formatted and corrected address, along with validation information. This provides information on the validation status of the individual components.

Address components are not ordered in a particular way. Do not make any assumptions on the ordering of the address components in the list.

pub fn set_missing_component_types(&mut self, val: Vec<String>) -> &mut Self

The types of components that were expected to be present in a correctly formatted mailing address but were not found in the input AND could not be inferred. Components of this type are not present in formattedAddress, postalAddress, or addressComponents. An example might be ['street_number', 'route'] for an input like “Boulder, Colorado, 80301, USA”. The list of possible types can be found here.

pub fn set_unconfirmed_component_types(&mut self, val: Vec<String>) -> &mut Self

The types of the components that are present in the addressComponents but could not be confirmed to be correct. This field is provided for the sake of convenience: its contents are equivalent to iterating through the addressComponents to find the types of all the components where the confirmationLevel is not CONFIRMED or the inferred flag is not set to true. The list of possible types can be found here.

pub fn set_unresolved_tokens(&mut self, val: Vec<String>) -> &mut Self

Any tokens in the input that could not be resolved. This might be an input that was not recognized as a valid part of an address. For example, for an input such as “Parcel 0000123123 & 0000456456 Str # Guthrie Center IA 50115 US”, the unresolved tokens might look like ["Parcel", "0000123123", "&", "0000456456"].

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Address

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

Formats the value using the given formatter.

impl Default for Address

fn default() -> Address

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Address

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Address

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Address

fn cmp(&self, other: &Address) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Address

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl PartialOrd for Address

fn partial_cmp(&self, other: &Address) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Address

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Address

impl StructuralPartialEq for Address