Enum rtrend::country::Country

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

Create a new Country.

Returns a Country instance.

Example

let country = Country::FR;

Variants

ALL

ID

FI

SC

HT

CG

BL

GF

TD

DJ

TL

GA

CI

YT

TG

GP

BJ

CD

KM

ML

MQ

GN

SN

NC

RE

CM

PF

GG

GB

NE

GI

BI

FR

MG

BF

MU

HN

JE

KY

TN

MR

DZ

MA

IM

CU

LU

BE

QA

CN

MW

SH

AE

PE

SV

EC

MX

BO

BN

NI

BM

CO

LB

CH

PY

ES

CL

UY

GT

CA

CW

AR

PA

VE

DO

KH

CR

SG

IE

MO

RW

AD

HK

AM

PH

MY

PG

EE

TT

SL

MN

CY

PR

SE

AU

AO

SK

AZ

CZ

AL

IS

NZ

KE

MZ

KW

OM

TR

BH

MK

JM

US

MT

XK

TW

BT

DK

RO

NL

PT

UZ

GH

ZW

DE

PL

ME

KR

PK

TZ

IT

LA

IN

RS

AT

ZA

BR

RU

ET

MM

NO

HU

NA

SI

LV

MD

VN

LT

LR

BA

UG

NG

ZM

BG

MV

GE

HR

NP

GR

UA

KG

LY

LK

IL

JO

BY

EG

AF

TH

BD

SA

KZ

PS

SD

JP

BB

IQ

YE

BS

IR

SY

MS

GQ

ST

PM

CF

GW

SX

MP

KN

VG

DM

TC

SZ

VI

GM

SR

BW

GY

GD

SO

FJ

EH

AW

GU

LC

SS

LS

TM

TJ

AI

AX

AS

AQ

TF

AG

BQ

BZ

BV

CC

CK

CV

CX

ER

FK

FO

FM

GL

HM

IO

KI

LI

MF

MC

MH

NF

NU

NR

PN

PW

KP

GS

SJ

SB

SM

TK

TO

TV

UM

VA

VC

VU

WF

WS

Trait Implementations

impl Clone for Country

fn clone(&self) -> Country

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<'_>) -> Result

Formats the value using the given formatter.

impl Display for Country

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

Formats the value using the given formatter.

impl FromStr for Country

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl PartialEq<Country> for Country

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

type Error = ParseError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for Country

impl StructuralEq for Country

impl StructuralPartialEq for Country