Enum 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 Clone for Component

fn clone(&self) -> Component

Returns a duplicate 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<V> Enum<V> for Component

type Array = [V; 21]

Representation of an enum map for type V.

fn from_usize(value: usize) -> Self

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

fn into_usize(self) -> usize

Returns an unique identifier for a value within range of 0..Array::LENGTH.

impl FromStr for Component

type Err = ParseError

The associated error which can be returned from parsing.

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

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

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for Component

type Iterator = ComponentIter

fn iter() -> ComponentIter

impl PartialEq for Component

fn eq(&self, other: &Component) -> 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 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 TryFrom<&str> for Component

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Component, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Copy for Component

impl Eq for Component

impl StructuralPartialEq for Component