Enum City 

pub enum City {
    Edinburgh,
    London,
    Dieppe,
    Amsterdam,
    Brest,
    Paris,
    Bruxelles,
    Essen,
    Frankfurt,
    Pamplona,
    Zuerich,
    Marseille,
    Kobenhavn,
    Berlin,
    Muenchen,
    Madrid,
    Barcelona,
    Venezia,
    Roma,
    Stockholm,
    Danzig,
    Warszawa,
    Wien,
    Lisboa,
    Cadiz,
    Zagrab,
    Brindisi,
    Palermo,
    Petrograd,
    Riga,
    Wilno,
    Kyiv,
    Budapest,
    Sarajevo,
    Athina,
    Smyrna,
    Moskva,
    Smolensk,
    Kharkov,
    Bucuresti,
    Sofia,
    Constantinople,
    Angora,
    Rostov,
    Sevastopol,
    Erzurum,
    Sochi,
}

All available cities of the game are included into this handy enumeration, so that my code is more clear. The cities are not entered with any particular order, I just started from Edinburgh and traversed the map gradually most of the times randomly.

Variants

Edinburgh

These are all cities included in the board game of Ticket to Ride, Europe edition. They don’t have a specific meaning to be documented, other than that they are a nice way to keep track for me.

London

Dieppe

Amsterdam

Brest

Paris

Bruxelles

Essen

Frankfurt

Pamplona

Zuerich

Marseille

Kobenhavn

Berlin

Muenchen

Madrid

Barcelona

Venezia

Roma

Stockholm

Danzig

Warszawa

Wien

Lisboa

Cadiz

Zagrab

Brindisi

Palermo

Petrograd

Riga

Wilno

Kyiv

Budapest

Sarajevo

Athina

Smyrna

Moskva

Smolensk

Kharkov

Bucuresti

Sofia

Constantinople

Angora

Rostov

Sevastopol

Erzurum

Sochi

Trait Implementations

impl Clone for City

fn clone(&self) -> City

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for City

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

Formats the value using the given formatter.

impl FromStr for City

The FromStr trait gives to the enumeration the handy from_str function that is used to convert a string (provided by command line arguments) to a City. I had to map each string to the specific city.

Example

let start_city = "Athina"; // This could come from clap
let begin = City::from_str(start_city).unwrap();

type Err = ()

The associated error which can be returned from parsing.

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

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

impl Hash for City

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 City

type Iterator = CityIter

fn iter() -> CityIter

impl PartialEq for City

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

impl Eq for City

impl StructuralPartialEq for City