Enum CountryCodeSupported

#[non_exhaustive]
pub enum CountryCodeSupported {
    AD,
    AE,
    AG,
    AI,
    AL,
    AM,
    AO,
    AR,
    AS,
    AT,
    AU,
    AW,
    AX,
    AZ,
    BA,
    BB,
    BD,
    BE,
    BF,
    BG,
    BH,
    BI,
    BJ,
    BL,
    BM,
    BN,
    BO,
    BQ,
    BR,
    BS,
    BT,
    BV,
    BW,
    BZ,
    CA,
    CC,
    CG,
    CH,
    CI,
    CK,
    CL,
    CM,
    CN,
    CO,
    CR,
    CV,
    CW,
    CX,
    CY,
    CZ,
    DE,
    DJ,
    DK,
    DM,
    DO,
    DZ,
    EC,
    EE,
    EG,
    EH,
    ER,
    ES,
    ET,
    FI,
    FJ,
    FK,
    FM,
    FO,
    FR,
    GA,
    GB,
    GD,
    GE,
    GF,
    GG,
    GH,
    GI,
    GL,
    GM,
    GN,
    GP,
    GQ,
    GR,
    GS,
    GT,
    GU,
    GW,
    GY,
    HK,
    HM,
    HN,
    HR,
    HU,
    ID,
    IE,
    IL,
    IM,
    IN,
    IO,
    IQ,
    IS,
    IT,
    JE,
    JM,
    JO,
    JP,
    KE,
    KG,
    KH,
    KI,
    KM,
    KN,
    KR,
    KW,
    KY,
    KZ,
    LA,
    LB,
    LC,
    LI,
    LK,
    LR,
    LS,
    LT,
    LU,
    LV,
    MA,
    MC,
    MD,
    ME,
    MF,
    MG,
    MH,
    MK,
    MN,
    MO,
    MP,
    MQ,
    MR,
    MS,
    MT,
    MU,
    MV,
    MW,
    MX,
    MY,
    MZ,
    NA,
    NC,
    NE,
    NF,
    NG,
    NL,
    NO,
    NP,
    NR,
    NU,
    NZ,
    OM,
    PA,
    PE,
    PF,
    PG,
    PH,
    PK,
    PL,
    PM,
    PN,
    PR,
    PS,
    PT,
    PW,
    PY,
    QA,
    RE,
    RO,
    RS,
    RW,
    SA,
    SB,
    SC,
    SE,
    SG,
    SH,
    SI,
    SJ,
    SK,
    SL,
    SM,
    SN,
    SR,
    ST,
    SV,
    SX,
    SZ,
    TC,
    TD,
    TF,
    TG,
    TH,
    TJ,
    TK,
    TL,
    TM,
    TN,
    TO,
    TR,
    TT,
    TV,
    TW,
    TZ,
    UA,
    UG,
    UM,
    US,
    UY,
    UZ,
    VA,
    VC,
    VG,
    VI,
    VN,
    VU,
    WF,
    WS,
    XK,
    YT,
    ZA,
    ZM,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

AD

Andorra

AE

United Arab Emirates

AG

Antigua and Barbuda

AI

Anguilla

AL

Albania

AM

Armenia

AO

Angola

AR

Argentina

AS

American Samoa

AT

Austria

AU

Australia

AW

Aruba

AX

Åland Islands

AZ

Azerbaijan

BA

Bosnia and Herzegovina

BB

Barbados

BD

Bangladesh

BE

Belgium

BF

Burkina Faso

BG

Bulgaria

BH

Bahrain

BI

Burundi

BJ

Benin

BL

Saint Barthélemy

BM

Bermuda

BN

Brunei

BO

Bolivia

BQ

Caribbean Netherlands (Bonaire, Sint Eustatius, and Saba)

BR

Brazil

BS

Bahamas

BT

Bhutan

BV

Bouvet Island

BW

Botswana

BZ

Belize

CA

Canada

CC

Cocos Islands

CG

Republic of Congo

CH

Switzerland

CI

Côte d’Ivoire (Ivory Coast)

CK

Cook Islands

CL

Chile

CM

Cameroon

CN

China

CO

Colombia

CR

Costa Rica

CV

Cape Verde

CW

Curaçao

CX

Christmas Island

CY

Cyprus

CZ

Czechia (Czech Republic)

DE

Germany

DJ

Djibouti

DK

Denmark

DM

Dominica

DO

Dominican Republic

DZ

Algeria

EC

Ecuador

EE

Estonia

EG

Egypt

EH

Western Sahara

ER

Eritrea

ES

Spain

ET

Ethiopia

FI

Finland

FJ

Fiji

FK

Falkland Islands

FM

Micronesia

FO

Faroe Islands

FR

France

GA

Gabon

GB

United Kingdom

GD

Grenada

GE

Georgia

GF

French Guiana

GG

Guernsey

GH

Ghana

GI

Gibraltar

GL

Greenland

GM

Gambia

GN

Guinea

GP

Guadeloupe

GQ

Equatorial Guinea

GR

Greece

GS

South Georgia and the South Sandwich Islands

GT

Guatemala

GU

Guam

GW

Guinea-Bissau

GY

Guyana

HK

Hong Kong

HM

Heard Island and McDonald Islands

HN

Honduras

HR

Croatia

HU

Hungary

ID

Indonesia

IE

Ireland

IL

Israel

IM

Isle of Man

IN

India

IO

British Indian Ocean Territory

IQ

Iraq

IS

Iceland

IT

Italy

JE

Jersey

JM

Jamaica

JO

Jordan

JP

Japan

KE

Kenya

KG

Kyrgyzstan

KH

Cambodia

KI

Kiribati

KM

Comoros

KN

Saint Kitts and Nevis

KR

South Korea

KW

Kuwait

KY

Cayman Islands

KZ

Kazakhstan

LA

Lao People’s Democratic Republic (Laos)

LB

Lebanon

LC

Saint Lucia

LI

Liechtenstein

LK

Sri Lanka

LR

Liberia

LS

Lesotho

LT

Lithuania

LU

Luxembourg

LV

Latvia

MA

Morocco

MC

Monaco

MD

Moldova

ME

Montenegro

MF

Saint Martin

MG

Madagascar

MH

Marshall Islands

MK

Macedonia

MN

Mongolia

MO

Macao

MP

Northern Mariana Islands

MQ

Martinique

MR

Mauritania

MS

Montserrat

MT

Malta

MU

Mauritius

MV

Maldives

MW

Malawi

MX

Mexico

MY

Malaysia

MZ

Mozambique

NA

Namibia

NC

New Caledonia

NE

Niger

NF

Norfolk Island

NG

Nigeria

NL

Netherlands

NO

Norway

NP

Nepal

NR

Nauru

NU

Niue

NZ

New Zealand

OM

Oman

PA

Panama

PE

Peru

PF

French Polynesia

PG

Papua New Guinea

PH

Philippines

PK

Pakistan

PL

Poland

PM

Saint Pierre and Miquelon

PN

Pitcairn

PR

Puerto Rico

PS

Palestinian territories

PT

Portugal

PW

Palau

PY

Paraguay

QA

Qatar

RE

Reunion

RO

Romania

RS

Republic of Serbia

RW

Rwanda

SA

Saudi Arabia

SB

Solomon Islands

SC

Seychelles

SE

Sweden

SG

Singapore

SH

Saint Helena

SI

Slovenia

SJ

Svalbard and Jan Mayen

SK

Slovakia

SL

Sierra Leone

SM

San Marino

SN

Senegal

SR

Suriname

ST

São Tomé and Príncipe

SV

El Salvador

SX

Sint Maarten

SZ

Swaziland

TC

Turks and Caicos Islands

TD

Chad

TF

French Southern and Antarctic Lands

TG

Togo

TH

Thailand

TJ

Tajikistan

TK

Tokelau

TL

Timor-Leste

TM

Turkmenistan

TN

Tunisia

TO

Tonga

TR

Turkey

TT

Trinidad and Tobago

TV

Tuvalu

TW

Taiwan

TZ

Tanzania

UA

Ukraine

UG

Uganda

UM

United States Minor Outlying Islands

US

United States

UY

Uruguay

UZ

Uzbekistan

VA

Holy See (Vatican City)

VC

Saint Vincent and the Grenadines

VG

British Virgin Islands

VI

U.S. Virgin Islands

VN

Vietnam

VU

Vanuatu

WF

Wallis and Futuna

WS

Samoa

XK

Kosovo

YT

Mayotte

ZA

South Africa

ZM

Zambia

Trait Implementations

impl Clone for CountryCodeSupported

fn clone(&self) -> CountryCodeSupported

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CountryCodeSupported

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CountryCodeSupported

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CountryCodeSupported

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 CountryCodeSupported

fn cmp(&self, other: &CountryCodeSupported) -> 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 CountryCodeSupported

fn eq(&self, other: &CountryCodeSupported) -> 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 CountryCodeSupported

fn partial_cmp(&self, other: &CountryCodeSupported) -> 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 CountryCodeSupported

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 CountryCodeSupported

impl StructuralPartialEq for CountryCodeSupported