Enum address_formatter::Component

pub enum Component {
    Attention,
    HouseNumber,
    House,
    Road,
    Village,
    Suburb,
    City,
    County,
    CountyCode,
    Postcode,
    StateDistrict,
    State,
    StateCode,
    Region,
    Island,
    Neighbourhood,
    Country,
    CountryCode,
    Continent,
    Town,
    CityDistrict,
}

A Component is a field of a Place

Variants

Attention

Leftover field. Can hold a name of a POI, name of building, ... will often be display first

HouseNumber

house_number of the place

House

house of the place

Road

road of the place

Village

village of the place

Suburb

suburb of the place

City

city of the place

County

county of the place

CountyCode

county_code of the place

Postcode

postcode of the place

StateDistrict

state_district of the place

State

state of the place

StateCode

state_code of the place

Region

region of the place

Island

island of the place

Neighbourhood

neighbourhood of the place

Country

country of the place

CountryCode

country_code of the place

Continent

continent of the place

Town

town of the place

CityDistrict

city_district of the place

Trait Implementations

impl Eq for Component

impl PartialEq<Component> for Component

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

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

#[must_use]

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

This method tests for !=.

impl Copy for Component

impl Clone for Component

fn clone(&self) -> Component

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Component

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

Formats the value using the given formatter.

impl Display for Component

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

Formats the value using the given formatter.

impl Hash for Component

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, 

Feeds a slice of this type into the given [Hasher].

impl FromStr for Component

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Component, Self::Err>

Parses a string s to return a value of this type.

impl IntoEnumIterator for Component

type Iterator = ComponentIter

fn iter() -> ComponentIter

impl Serialize for Component

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<V> Enum<V> for Component

type Array = [V; 21]

Representation of an enum map for type V, usually an array.

const POSSIBLE_VALUES: usize

Number of possible states the type can have.

fn slice(array: &Self::Array) -> &[V]

Gets a slice from an array type.

fn slice_mut(array: &mut Self::Array) -> &mut [V]

Gets a mutable slice from an array type.

fn from_usize(value: usize) -> Self

Takes an usize, and returns an element matching to_usize function.

fn to_usize(self) -> usize

Returns an unique identifier for a value within range of 0..POSSIBLE_VALUES.

fn from_function<F: FnMut(Self) -> V>(_f: F) -> Self::Array

Creates an array using a function called for each argument.