Struct celes::Country

pub struct Country {
    pub code: &'static str,
    pub value: usize,
    pub alpha2: &'static str,
    pub alpha3: &'static str,
    pub long_name: &'static str,
    pub aliases: CountryTable,
}

Represents a country according to ISO 3166

Fields

code: &'static str

The three digit code assigned to the country

value: usize

The integer value for code

alpha2: &'static str

The two letter country code (alpha-2) assigned to the country

alpha3: &'static str

The three letter country code (alpha-3) assigned to the country

long_name: &'static str

The official state name of the country

aliases: CountryTable

Common aliases associated with the country

Implementations

impl Country

pub fn afghanistan() -> Self

Creates a struct for Afghanistan

pub fn aland_islands() -> Self

Creates a struct for Aland Islands

pub fn albania() -> Self

Creates a struct for Albania

pub fn algeria() -> Self

Creates a struct for Algeria

pub fn american_samoa() -> Self

Creates a struct for American Samoa

pub fn andorra() -> Self

Creates a struct for Andorra

pub fn angola() -> Self

Creates a struct for Angola

pub fn anguilla() -> Self

Creates a struct for Anguilla

pub fn antarctica() -> Self

Creates a struct for Antarctica

pub fn antigua_and_barbuda() -> Self

Creates a struct for Antigua And Barbuda

pub fn argentina() -> Self

Creates a struct for Argentina

pub fn armenia() -> Self

Creates a struct for Armenia

pub fn aruba() -> Self

Creates a struct for Aruba

pub fn ascension_and_tristan_da_cunha_saint_helena() -> Self

Creates a struct for Ascension And Tristan Da Cunha Saint Helena

pub fn australia() -> Self

Creates a struct for Australia

pub fn austria() -> Self

Creates a struct for Austria

pub fn azerbaijan() -> Self

Creates a struct for Azerbaijan

pub fn bahrain() -> Self

Creates a struct for Bahrain

pub fn bangladesh() -> Self

Creates a struct for Bangladesh

pub fn barbados() -> Self

Creates a struct for Barbados

pub fn belarus() -> Self

Creates a struct for Belarus

pub fn belgium() -> Self

Creates a struct for Belgium

pub fn belize() -> Self

Creates a struct for Belize

pub fn benin() -> Self

Creates a struct for Benin

pub fn bermuda() -> Self

Creates a struct for Bermuda

pub fn bhutan() -> Self

Creates a struct for Bhutan

pub fn bolivarian_republic_of_venezuela() -> Self

Creates a struct for Bolivarian Republic Of Venezuela

pub fn bolivia() -> Self

Creates a struct for Bolivia

pub fn bonaire() -> Self

Creates a struct for Bonaire

pub fn bosnia_and_herzegovina() -> Self

Creates a struct for Bosnia And Herzegovina

pub fn botswana() -> Self

Creates a struct for Botswana

pub fn bouvet_island() -> Self

Creates a struct for Bouvet Island

pub fn brazil() -> Self

Creates a struct for Brazil

pub fn british_indian_ocean_territory() -> Self

Creates a struct for British Indian Ocean Territory

pub fn british_virgin_islands() -> Self

Creates a struct for British Virgin Islands

pub fn brunei_darussalam() -> Self

Creates a struct for Brunei Darussalam

pub fn bulgaria() -> Self

Creates a struct for Bulgaria

pub fn burkina_faso() -> Self

Creates a struct for Burkina Faso

pub fn burundi() -> Self

Creates a struct for Burundi

pub fn cabo_verde() -> Self

Creates a struct for Cabo Verde

pub fn cambodia() -> Self

Creates a struct for Cambodia

pub fn cameroon() -> Self

Creates a struct for Cameroon

pub fn canada() -> Self

Creates a struct for Canada

pub fn chad() -> Self

Creates a struct for Chad

pub fn chile() -> Self

Creates a struct for Chile

pub fn china() -> Self

Creates a struct for China

pub fn christmas_island() -> Self

Creates a struct for Christmas Island

pub fn colombia() -> Self

Creates a struct for Colombia

pub fn costa_rica() -> Self

Creates a struct for Costa Rica

pub fn coted_ivoire() -> Self

Creates a struct for Coted Ivoire

pub fn croatia() -> Self

Creates a struct for Croatia

pub fn cuba() -> Self

Creates a struct for Cuba

pub fn curacao() -> Self

Creates a struct for Curacao

pub fn cyprus() -> Self

Creates a struct for Cyprus

pub fn czechia() -> Self

Creates a struct for Czechia

pub fn denmark() -> Self

Creates a struct for Denmark

pub fn djibouti() -> Self

Creates a struct for Djibouti

pub fn dominica() -> Self

Creates a struct for Dominica

pub fn dutch_part_sint_maarten() -> Self

Creates a struct for Dutch Part Sint Maarten

pub fn ecuador() -> Self

Creates a struct for Ecuador

pub fn egypt() -> Self

Creates a struct for Egypt

pub fn el_salvador() -> Self

Creates a struct for El Salvador

pub fn equatorial_guinea() -> Self

Creates a struct for Equatorial Guinea

pub fn eritrea() -> Self

Creates a struct for Eritrea

pub fn estonia() -> Self

Creates a struct for Estonia

pub fn eswatini() -> Self

Creates a struct for Eswatini

pub fn ethiopia() -> Self

Creates a struct for Ethiopia

pub fn federated_states_of_micronesia() -> Self

Creates a struct for Federated States Of Micronesia

pub fn fiji() -> Self

Creates a struct for Fiji

pub fn finland() -> Self

Creates a struct for Finland

pub fn france() -> Self

Creates a struct for France

pub fn french_guiana() -> Self

Creates a struct for French Guiana

pub fn french_part_saint_martin() -> Self

Creates a struct for French Part Saint Martin

pub fn french_polynesia() -> Self

Creates a struct for French Polynesia

pub fn gabon() -> Self

Creates a struct for Gabon

pub fn georgia() -> Self

Creates a struct for Georgia

pub fn germany() -> Self

Creates a struct for Germany

pub fn ghana() -> Self

Creates a struct for Ghana

pub fn gibraltar() -> Self

Creates a struct for Gibraltar

pub fn greece() -> Self

Creates a struct for Greece

pub fn greenland() -> Self

Creates a struct for Greenland

pub fn grenada() -> Self

Creates a struct for Grenada

pub fn guadeloupe() -> Self

Creates a struct for Guadeloupe

pub fn guam() -> Self

Creates a struct for Guam

pub fn guatemala() -> Self

Creates a struct for Guatemala

pub fn guernsey() -> Self

Creates a struct for Guernsey

pub fn guinea() -> Self

Creates a struct for Guinea

pub fn guinea_bissau() -> Self

Creates a struct for Guinea Bissau

pub fn guyana() -> Self

Creates a struct for Guyana

pub fn haiti() -> Self

Creates a struct for Haiti

pub fn heard_island_and_mc_donald_islands() -> Self

Creates a struct for Heard Island And Mc Donald Islands

pub fn honduras() -> Self

Creates a struct for Honduras

pub fn hong_kong() -> Self

Creates a struct for Hong Kong

pub fn hungary() -> Self

Creates a struct for Hungary

pub fn iceland() -> Self

Creates a struct for Iceland

pub fn india() -> Self

Creates a struct for India

pub fn indonesia() -> Self

Creates a struct for Indonesia

pub fn iraq() -> Self

Creates a struct for Iraq

pub fn ireland() -> Self

Creates a struct for Ireland

pub fn islamic_republic_of_iran() -> Self

Creates a struct for Islamic Republic Of Iran

pub fn isle_of_man() -> Self

Creates a struct for Isle Of Man

pub fn israel() -> Self

Creates a struct for Israel

pub fn italy() -> Self

Creates a struct for Italy

pub fn jamaica() -> Self

Creates a struct for Jamaica

pub fn japan() -> Self

Creates a struct for Japan

pub fn jersey() -> Self

Creates a struct for Jersey

pub fn jordan() -> Self

Creates a struct for Jordan

pub fn kazakhstan() -> Self

Creates a struct for Kazakhstan

pub fn kenya() -> Self

Creates a struct for Kenya

pub fn kiribati() -> Self

Creates a struct for Kiribati

pub fn kosovo() -> Self

Creates a struct for Kosovo

pub fn kuwait() -> Self

Creates a struct for Kuwait

pub fn kyrgyzstan() -> Self

Creates a struct for Kyrgyzstan

pub fn latvia() -> Self

Creates a struct for Latvia

pub fn lebanon() -> Self

Creates a struct for Lebanon

pub fn lesotho() -> Self

Creates a struct for Lesotho

pub fn liberia() -> Self

Creates a struct for Liberia

pub fn libya() -> Self

Creates a struct for Libya

pub fn liechtenstein() -> Self

Creates a struct for Liechtenstein

pub fn lithuania() -> Self

Creates a struct for Lithuania

pub fn luxembourg() -> Self

Creates a struct for Luxembourg

pub fn macao() -> Self

Creates a struct for Macao

pub fn madagascar() -> Self

Creates a struct for Madagascar

pub fn malawi() -> Self

Creates a struct for Malawi

pub fn malaysia() -> Self

Creates a struct for Malaysia

pub fn maldives() -> Self

Creates a struct for Maldives

pub fn mali() -> Self

Creates a struct for Mali

pub fn malta() -> Self

Creates a struct for Malta

pub fn martinique() -> Self

Creates a struct for Martinique

pub fn mauritania() -> Self

Creates a struct for Mauritania

pub fn mauritius() -> Self

Creates a struct for Mauritius

pub fn mayotte() -> Self

Creates a struct for Mayotte

pub fn mexico() -> Self

Creates a struct for Mexico

pub fn monaco() -> Self

Creates a struct for Monaco

pub fn mongolia() -> Self

Creates a struct for Mongolia

pub fn montenegro() -> Self

Creates a struct for Montenegro

pub fn montserrat() -> Self

Creates a struct for Montserrat

pub fn morocco() -> Self

Creates a struct for Morocco

pub fn mozambique() -> Self

Creates a struct for Mozambique

pub fn myanmar() -> Self

Creates a struct for Myanmar

pub fn namibia() -> Self

Creates a struct for Namibia

pub fn nauru() -> Self

Creates a struct for Nauru

pub fn nepal() -> Self

Creates a struct for Nepal

pub fn new_caledonia() -> Self

Creates a struct for New Caledonia

pub fn new_zealand() -> Self

Creates a struct for New Zealand

pub fn nicaragua() -> Self

Creates a struct for Nicaragua

pub fn nigeria() -> Self

Creates a struct for Nigeria

pub fn niue() -> Self

Creates a struct for Niue

pub fn norfolk_island() -> Self

Creates a struct for Norfolk Island

pub fn norway() -> Self

Creates a struct for Norway

pub fn oman() -> Self

Creates a struct for Oman

pub fn pakistan() -> Self

Creates a struct for Pakistan

pub fn palau() -> Self

Creates a struct for Palau

pub fn panama() -> Self

Creates a struct for Panama

pub fn papua_new_guinea() -> Self

Creates a struct for Papua New Guinea

pub fn paraguay() -> Self

Creates a struct for Paraguay

pub fn peru() -> Self

Creates a struct for Peru

pub fn pitcairn() -> Self

Creates a struct for Pitcairn

pub fn poland() -> Self

Creates a struct for Poland

pub fn portugal() -> Self

Creates a struct for Portugal

pub fn puerto_rico() -> Self

Creates a struct for Puerto Rico

pub fn qatar() -> Self

Creates a struct for Qatar

pub fn republic_of_north_macedonia() -> Self

Creates a struct for Republic Of North Macedonia

pub fn reunion() -> Self

Creates a struct for Reunion

pub fn romania() -> Self

Creates a struct for Romania

pub fn rwanda() -> Self

Creates a struct for Rwanda

pub fn saint_barthelemy() -> Self

Creates a struct for Saint Barthelemy

pub fn saint_kitts_and_nevis() -> Self

Creates a struct for Saint Kitts And Nevis

pub fn saint_lucia() -> Self

Creates a struct for Saint Lucia

pub fn saint_pierre_and_miquelon() -> Self

Creates a struct for Saint Pierre And Miquelon

pub fn saint_vincent_and_the_grenadines() -> Self

Creates a struct for Saint Vincent And The Grenadines

pub fn samoa() -> Self

Creates a struct for Samoa

pub fn san_marino() -> Self

Creates a struct for San Marino

pub fn sao_tome_and_principe() -> Self

Creates a struct for Sao Tome And Principe

pub fn saudi_arabia() -> Self

Creates a struct for Saudi Arabia

pub fn senegal() -> Self

Creates a struct for Senegal

pub fn serbia() -> Self

Creates a struct for Serbia

pub fn seychelles() -> Self

Creates a struct for Seychelles

pub fn sierra_leone() -> Self

Creates a struct for Sierra Leone

pub fn singapore() -> Self

Creates a struct for Singapore

pub fn slovakia() -> Self

Creates a struct for Slovakia

pub fn slovenia() -> Self

Creates a struct for Slovenia

pub fn solomon_islands() -> Self

Creates a struct for Solomon Islands

pub fn somalia() -> Self

Creates a struct for Somalia

pub fn south_africa() -> Self

Creates a struct for South Africa

pub fn south_georgia_and_the_south_sandwich_islands() -> Self

Creates a struct for South Georgia And The South Sandwich Islands

pub fn south_sudan() -> Self

Creates a struct for South Sudan

pub fn spain() -> Self

Creates a struct for Spain

pub fn sri_lanka() -> Self

Creates a struct for Sri Lanka

pub fn state_of_palestine() -> Self

Creates a struct for State Of Palestine

pub fn suriname() -> Self

Creates a struct for Suriname

pub fn svalbard_and_jan_mayen() -> Self

Creates a struct for Svalbard And Jan Mayen

pub fn sweden() -> Self

Creates a struct for Sweden

pub fn switzerland() -> Self

Creates a struct for Switzerland

pub fn syrian_arab_republic() -> Self

Creates a struct for Syrian Arab Republic

pub fn taiwan_province_of_china() -> Self

Creates a struct for Taiwan Province Of China

pub fn tajikistan() -> Self

Creates a struct for Tajikistan

pub fn thailand() -> Self

Creates a struct for Thailand

pub fn the_bahamas() -> Self

Creates a struct for The Bahamas

pub fn the_cayman_islands() -> Self

Creates a struct for The Cayman Islands

pub fn the_central_african_republic() -> Self

Creates a struct for The Central African Republic

pub fn the_cocos_keeling_islands() -> Self

Creates a struct for The Cocos Keeling Islands

pub fn the_comoros() -> Self

Creates a struct for The Comoros

pub fn the_congo() -> Self

Creates a struct for The Congo

pub fn the_cook_islands() -> Self

Creates a struct for The Cook Islands

pub fn the_democratic_peoples_republic_of_korea() -> Self

Creates a struct for The Democratic Peoples Republic Of Korea

pub fn the_democratic_republic_of_the_congo() -> Self

Creates a struct for The Democratic Republic Of The Congo

pub fn the_dominican_republic() -> Self

Creates a struct for The Dominican Republic

pub fn the_falkland_islands_malvinas() -> Self

Creates a struct for The Falkland Islands Malvinas

pub fn the_faroe_islands() -> Self

Creates a struct for The Faroe Islands

pub fn the_french_southern_territories() -> Self

Creates a struct for The French Southern Territories

pub fn the_gambia() -> Self

Creates a struct for The Gambia

pub fn the_holy_see() -> Self

Creates a struct for The Holy See

pub fn the_lao_peoples_democratic_republic() -> Self

Creates a struct for The Lao Peoples Democratic Republic

pub fn the_marshall_islands() -> Self

Creates a struct for The Marshall Islands

pub fn the_netherlands() -> Self

Creates a struct for The Netherlands

pub fn the_niger() -> Self

Creates a struct for The Niger

pub fn the_northern_mariana_islands() -> Self

Creates a struct for The Northern Mariana Islands

pub fn the_philippines() -> Self

Creates a struct for The Philippines

pub fn the_republic_of_korea() -> Self

Creates a struct for The Republic Of Korea

pub fn the_republic_of_moldova() -> Self

Creates a struct for The Republic Of Moldova

pub fn the_russian_federation() -> Self

Creates a struct for The Russian Federation

pub fn the_sudan() -> Self

Creates a struct for The Sudan

pub fn the_turks_and_caicos_islands() -> Self

Creates a struct for The Turks And Caicos Islands

pub fn the_united_arab_emirates() -> Self

Creates a struct for The United Arab Emirates

pub fn the_united_kingdom_of_great_britain_and_northern_ireland() -> Self

Creates a struct for The United Kingdom Of Great Britain And Northern Ireland

pub fn the_united_states_minor_outlying_islands() -> Self

Creates a struct for The United States Minor Outlying Islands

pub fn the_united_states_of_america() -> Self

Creates a struct for The United States Of America

pub fn timor_leste() -> Self

Creates a struct for Timor Leste

pub fn togo() -> Self

Creates a struct for Togo

pub fn tokelau() -> Self

Creates a struct for Tokelau

pub fn tonga() -> Self

Creates a struct for Tonga

pub fn trinidad_and_tobago() -> Self

Creates a struct for Trinidad And Tobago

pub fn tunisia() -> Self

Creates a struct for Tunisia

pub fn turkey() -> Self

Creates a struct for Turkey

pub fn turkmenistan() -> Self

Creates a struct for Turkmenistan

pub fn tuvalu() -> Self

Creates a struct for Tuvalu

pub fn us_virgin_islands() -> Self

Creates a struct for US Virgin Islands

pub fn uganda() -> Self

Creates a struct for Uganda

pub fn ukraine() -> Self

Creates a struct for Ukraine

pub fn united_republic_of_tanzania() -> Self

Creates a struct for United Republic Of Tanzania

pub fn uruguay() -> Self

Creates a struct for Uruguay

pub fn uzbekistan() -> Self

Creates a struct for Uzbekistan

pub fn vanuatu() -> Self

Creates a struct for Vanuatu

pub fn vietnam() -> Self

Creates a struct for Vietnam

pub fn wallis_and_futuna() -> Self

Creates a struct for Wallis And Futuna

pub fn western_sahara() -> Self

Creates a struct for Western Sahara

pub fn yemen() -> Self

Creates a struct for Yemen

pub fn zambia() -> Self

Creates a struct for Zambia

pub fn zimbabwe() -> Self

Creates a struct for Zimbabwe

pub fn get_countries() -> [Self; 250]

Returns a vector in alphabetic order of all the countries

use celes::Country;
use std::collections::BTreeMap;

let countries = Country::get_countries();


for c in &countries {
    println!("{}", c);
}

for c in &countries {
    println!("{}", c.alpha2);
}

for c in countries.iter().filter(|cty| cty.value < 300) {
    println!("{}", c.long_name)
}

//Convert to a map
let lookup = countries.iter().map(|cty| (cty.alpha2.to_string(), cty.clone())).collect::<BTreeMap<String, Country>>();

pub fn from_value(value: usize) -> Result<Self, &'static str>

Given the numeric code, return a country or an error if the parameter doesn’t match any country

use celes::Country;

let res = Country::from_value(1);
assert!(res.is_err());

let res = Country::from_value(2);
assert!(res.is_err());

let res = Country::from_value(4);
assert!(res.is_ok());

assert_eq!(Country::afghanistan(), res.unwrap());

pub fn from_code<A: AsRef<str>>(code: A) -> Result<Self, &'static str>

Given the three digit code, return a country or an error if the parameter doesn’t match any country. The value MUST be the three digit code which includes leading zeros.

use celes::Country;

let res = Country::from_code("8");
assert!(res.is_err());

let res = Country::from_code("08");
assert!(res.is_err());

let res = Country::from_code("008");
assert!(res.is_ok());

assert_eq!(Country::albania(), res.unwrap());

pub fn from_alpha2<A: AsRef<str>>(alpha2: A) -> Result<Self, &'static str>

Given the alpha2 letters, return a country or an error if the parameter doesn’t match any country. This is case-insensitive.

use celes::Country;

let res = Country::from_alpha2("u");
assert!(res.is_err());

let res = Country::from_alpha2("us");
assert!(res.is_ok());
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_alpha2("Us");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_alpha2("uS");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_alpha2("US");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

pub fn from_alpha3<A: AsRef<str>>(alpha3: A) -> Result<Self, &'static str>

Given the alpha3 letters, return a country or an error if the parameter doesn’t match any country. This is case-insensitive.

use celes::Country;

let res = Country::from_alpha3("u");
assert!(res.is_err());

let res = Country::from_alpha3("us");
assert!(res.is_err());

let res = Country::from_alpha3("Usa");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_alpha3("uSa");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_alpha3("USA");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

pub fn from_alias<A: AsRef<str>>(alias: A) -> Result<Self, &'static str>

Given the a country alias, return a country or an error if the parameter doesn’t match any country

The alias is any value in the aliases field for a country. For example, “america” would return the_united_states_of_america This is case-insensitive.

use celes::Country;

let res = Country::from_alias("u");
assert!(res.is_err());

let res = Country::from_alias("us");
assert!(res.is_err());

let res = Country::from_alias("america");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_alias("russia");
assert_eq!(Country::the_russian_federation(), res.unwrap());

let res = Country::from_alias("england");
assert_eq!(Country::the_united_kingdom_of_great_britain_and_northern_ireland(), res.unwrap());

pub fn from_name<A: AsRef<str>>(name: A) -> Result<Self, &'static str>

Given the country name, return a country or an error if the parameter doesn’t match any country. This is case-insensitive.

For example, Albania, Algeria, Brazil would return the country struct that represents those countries.

use celes::Country;

let res = Country::from_name("russianfederation");
assert!(res.is_err());

let res = Country::from_name("unitedstatesofamerica");
assert!(res.is_err());

let res = Country::from_name("Albania");
assert_eq!(Country::albania(), res.unwrap());

let res = Country::from_name("theunitedstatesofamerica");
assert_eq!(Country::the_united_states_of_america(), res.unwrap());

let res = Country::from_name("therussianfederation");
assert_eq!(Country::the_russian_federation(), res.unwrap());

let res = Country::from_name("theunitedkingdomofgreatbritainandnorthernireland");
assert_eq!(Country::the_united_kingdom_of_great_britain_and_northern_ireland(), res.unwrap());

Trait Implementations

impl Clone for Country

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Country

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Country

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Country

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

Formats the value using the given formatter.

impl FromStr for Country

type Err = &'static str

The associated error which can be returned from parsing.

fn from_str(code: &str) -> Result<Self, &'static str>

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

impl Hash for Country

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 Ord for Country

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<Country> for Country

fn eq(&self, other: &Self) -> 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 PartialOrd<Country> for Country

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Serialize for Country

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

Serialize this value into the given Serde serializer.

impl Copy for Country

impl Eq for Country