Enum Country 

pub enum Country {
    AD,
    AL,
    AM,
    AR,
    AT,
    AU,
    AX,
    BA,
    BB,
    BE,
    BG,
    BJ,
    BO,
    BR,
    BS,
    BW,
    BY,
    BZ,
    CA,
    CD,
    CG,
    CH,
    CL,
    CN,
    CO,
    CR,
    CU,
    CY,
    CZ,
    DE,
    DK,
    DO,
    EC,
    EE,
    EG,
    ES,
    FI,
    FO,
    FR,
    GA,
    GB,
    GD,
    GE,
    GG,
    GH,
    GI,
    GL,
    GM,
    GR,
    GT,
    GY,
    HK,
    HN,
    HR,
    HT,
    HU,
    ID,
    IE,
    IM,
    IS,
    IT,
    JE,
    JM,
    JP,
    KE,
    KR,
    KZ,
    LI,
    LS,
    LT,
    LU,
    LV,
    MA,
    MC,
    MD,
    ME,
    MG,
    MK,
    MN,
    MS,
    MT,
    MX,
    MZ,
    NA,
    NE,
    NG,
    NI,
    NL,
    NO,
    NZ,
    PA,
    PE,
    PG,
    PH,
    PL,
    PR,
    PT,
    PY,
    RO,
    RS,
    RU,
    SC,
    SE,
    SG,
    SI,
    SJ,
    SK,
    SM,
    SR,
    SV,
    TN,
    TR,
    UA,
    US,
    UY,
    VA,
    VE,
    VN,
    ZA,
    ZW,
}

An enum for selecting a country.

use opening_hours::localization::Country;

let country: Country = "FR".parse().unwrap();
assert_eq!(country, Country::FR);

Variants

AD

Andorra

AL

Albania

AM

Armenia

AR

Argentina

AT

Austria

AU

Australia

AX

Åland Islands

BA

Bosnia and Herzegovina

BB

Barbados

BE

Belgium

BG

Bulgaria

BJ

Benin

BO

Bolivia

BR

Brazil

BS

Bahamas

BW

Botswana

BY

Belarus

BZ

Belize

CA

Canada

CD

DR Congo

CG

Congo

CH

Switzerland

CL

Chile

CN

China

CO

Colombia

CR

Costa Rica

CU

Cuba

CY

Cyprus

CZ

Czechia

DE

Germany

DK

Denmark

DO

Dominican Republic

EC

Ecuador

EE

Estonia

EG

Egypt

ES

Spain

FI

Finland

FO

Faroe Islands

FR

France

GA

Gabon

GB

United Kingdom

GD

Grenada

GE

Georgia

GG

Guernsey

GH

Ghana

GI

Gibraltar

GL

Greenland

GM

Gambia

GR

Greece

GT

Guatemala

GY

Guyana

HK

Hong Kong

HN

Honduras

HR

Croatia

HT

Haiti

HU

Hungary

ID

Indonesia

IE

Ireland

IM

Isle of Man

IS

Iceland

IT

Italy

JE

Jersey

JM

Jamaica

JP

Japan

KE

Kenya

KR

South Korea

KZ

Kazakhstan

LI

Liechtenstein

LS

Lesotho

LT

Lithuania

LU

Luxembourg

LV

Latvia

MA

Morocco

MC

Monaco

MD

Moldova

ME

Montenegro

MG

Madagascar

MK

North Macedonia

MN

Mongolia

MS

Montserrat

MT

Malta

MX

Mexico

MZ

Mozambique

NA

Namibia

NE

Niger

NG

Nigeria

NI

Nicaragua

NL

Netherlands

NO

Norway

NZ

New Zealand

PA

Panama

PE

Peru

PG

Papua New Guinea

PH

Philippines

PL

Poland

PR

Puerto Rico

PT

Portugal

PY

Paraguay

RO

Romania

RS

Serbia

RU

Russia

SC

Seychelles

SE

Sweden

SG

Singapore

SI

Slovenia

SJ

Svalbard and Jan Mayen

SK

Slovakia

SM

San Marino

SR

Suriname

SV

El Salvador

TN

Tunisia

TR

Türkiye

UA

Ukraine

US

United States

UY

Uruguay

VA

Vatican City

VE

Venezuela

VN

Vietnam

ZA

South Africa

ZW

Zimbabwe

Implementations

impl Country

pub const ALL: [Self; 120]

pub fn name(self) -> &'static str

Get the country’s full name.

use opening_hours::localization::Country;

assert_eq!(Country::FR.name(), "France");

pub fn iso_code(self) -> &'static str

Get the country’s iso code.

use opening_hours::localization::Country;

assert_eq!(Country::FR.iso_code(), "FR");

impl Country

pub fn try_from_coords(coords: Coordinates) -> Option<Self>

Available on crate feature auto-country only.

Attempt to automatically detect a country from coordinates.

use opening_hours::localization::{Coordinates, Country};

let coords = Coordinates::new(48.86, 2.34).unwrap();
let country_paris = Country::try_from_coords(coords).unwrap();
assert_eq!(country_paris, Country::FR);

pub fn holidays(self) -> ContextHolidays

Load holidays for this country from a compact embedded database.

use chrono::NaiveDate;
use opening_hours::localization::Country;

let holidays_fr = Country::FR.holidays();
let date = NaiveDate::from_ymd_opt(2024, 7, 14).unwrap(); // french national day
assert!(holidays_fr.get_public().contains(date));

Trait Implementations

impl Clone for Country

fn clone(&self) -> Country

Returns a duplicate 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

Formats the value using the given formatter.

impl FromStr for Country

type Err = UnknownCountryCode

The associated error which can be returned from parsing.

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

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

Feeds a slice of this type into the given Hasher.

impl Ord for Country

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

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

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

impl Eq for Country

impl StructuralPartialEq for Country