wmata 7.1.0

//! MetroBus route related enum and methods.
use crate::{
    bus::{client::responses, traits::NeedsRoute},
    date::Date,
    error::Error,
    location::RadiusAtLatLong,
    requests::Fetch,
};
use serde::{
    de::{Deserializer, Error as SerdeError},
    Deserialize,
};
use std::{error, fmt, str::FromStr};

/// All MetroBus routes.
/// # Note
/// Some routes' name begins with a number (i.e. 10A). This is not allowed
/// by Rust naming conventions. As a fix, the first number of the route
/// has been replaced by a word. So, `10A` => `One0A`. This is unfortunate.
#[derive(Debug, Copy, Clone, PartialEq)]
pub enum Route {
    One0A,
    One0B,
    One0E,
    One0N,
    One1Y,
    One1Yv1,
    One1Yv2,
    One5K,
    One5Kv1,
    One6A,
    One6C,
    One6Cv1,
    One6E,
    One6G,
    One6Gv1,
    One6H,
    One6L,
    One6Y,
    One6Yv1,
    One7B,
    One7G,
    One7H,
    One7K,
    One7L,
    One7M,
    One8G,
    One8H,
    One8J,
    One8P,
    One8Pv1,
    One8Pv2,
    OneA,
    OneB,
    OneC,
    OneCv1,
    OneCv2,
    OneCv3,
    OneCv4,
    Two1A,
    Two1D,
    Two2A,
    Two2Av1,
    Two2C,
    Two2F,
    Two3A,
    Two3B,
    Two3Bv1,
    Two3T,
    Two5B,
    Two5Bv1,
    Two5Bv2,
    Two5Bv3,
    Two6A,
    Two8A,
    Two8Av1,
    Two8F,
    Two8G,
    Two9C,
    Two9G,
    Two9K,
    Two9Kv1,
    Two9N,
    Two9Nv1,
    Two9W,
    TwoA,
    TwoB,
    TwoBv1,
    TwoBv2,
    TwoBv3,
    Three0N,
    Three0S,
    Three1,
    Three2,
    Three2v1,
    Three3,
    Three4,
    Three6,
    Three7,
    Three8B,
    Three8Bv1,
    Three8Bv2,
    Three9,
    ThreeA,
    ThreeAv1,
    ThreeT,
    ThreeTv1,
    ThreeY,
    Four2,
    Four3,
    FourA,
    FourB,
    Five2,
    Five2v1,
    Five2v2,
    Five4,
    Five4v1,
    Five4v2,
    Five4v3,
    Five9,
    FiveA,
    Six0,
    Six2,
    Six2v1,
    Six3,
    Six4,
    Six4v1,
    Seven0,
    Seven0v1,
    Seven4,
    Seven9,
    SevenA,
    SevenAv1,
    SevenAv2,
    SevenAv3,
    SevenC,
    SevenF,
    SevenFv1,
    SevenM,
    SevenMv1,
    SevenP,
    SevenW,
    SevenY,
    SevenYv1,
    Eight0,
    Eight0v1,
    Eight0v2,
    Eight0v3,
    Eight3,
    Eight3v1,
    Eight3v2,
    Eight3v3,
    Eight3v4,
    Eight6,
    Eight6v1,
    Eight6v2,
    Eight7,
    Eight7v1,
    Eight7v2,
    Eight7v3,
    Eight7v4,
    Eight7v5,
    Eight9,
    Eight9v1,
    Eight9M,
    EightS,
    EightW,
    EightZ,
    Nine0,
    Nine0v1,
    Nine0v2,
    Nine2,
    Nine2v1,
    Nine2v2,
    Nine6,
    Nine6v1,
    Nine6v2,
    Nine6v3,
    Nine6v4,
    Nine6v5,
    Nine7,
    Nine7v1,
    A12,
    A12v1,
    A12v2,
    A12v3,
    A2,
    A2v1,
    A2v2,
    A2v3,
    A31,
    A32,
    A33,
    A4,
    A4v1,
    A4v2,
    A4v3,
    A4v4,
    A4v5,
    A6,
    A6v1,
    A7,
    A8,
    A8v1,
    A9,
    B2,
    B2v1,
    B2v2,
    B2v3,
    B2v4,
    B21,
    B22,
    B22v1,
    B24,
    B24v1,
    B27,
    B29,
    B29v1,
    B29v2,
    B30,
    B8,
    B8v1,
    B8v2,
    B9,
    B98,
    B99,
    C11,
    C12,
    C13,
    C14,
    C2,
    C2v1,
    C2v2,
    C2v3,
    C21,
    C21v1,
    C21v2,
    C22,
    C22v1,
    C26,
    C26v1,
    C28,
    C28v1,
    C29,
    C29_1,
    C29_2,
    C29_4,
    C290,
    C4,
    C4v1,
    C4v2,
    C4v3,
    C8,
    C8v1,
    C8v2,
    C8v3,
    D1,
    D12,
    D12v1,
    D12v2,
    D13,
    D13v1,
    D14,
    D14v1,
    D14v2,
    D2,
    D2v1,
    D31,
    D32,
    D33,
    D34,
    D4,
    D4v1,
    D4v2,
    D5,
    D51,
    D6,
    D6v1,
    D6v2,
    D6v3,
    D8,
    D8v1,
    E2,
    E4,
    E4v1,
    E4v2,
    E6,
    F1,
    F12,
    F12v1,
    F13,
    F13v1,
    F13v2,
    F13v3,
    F14,
    F14v1,
    F2,
    F2v1,
    F2v2,
    F4,
    F4v1,
    F4v2,
    F6,
    F6v1,
    F6v2,
    F8,
    F99,
    G12,
    G12v1,
    G12v2,
    G14,
    G14v1,
    G14v2,
    G2,
    G2v1,
    G8,
    G8v1,
    G8v2,
    G8v3,
    G9,
    G9v1,
    H1,
    H11,
    H12,
    H12v1,
    H13,
    H2,
    H3,
    H4,
    H4v1,
    H6,
    H6v1,
    H8,
    H9,
    J1,
    J1v1,
    J12,
    J12v1,
    J2,
    J2v1,
    J2v2,
    J4,
    K12,
    K12v1,
    K12v2,
    K2,
    K6,
    K6v1,
    K9,
    K9v1,
    L1,
    L2,
    L2v1,
    L2v2,
    L99,
    L8,
    M4,
    M4v1,
    M4v2,
    M6,
    M6v1,
    MW1,
    M99,
    N2,
    N4,
    N4v1,
    N6,
    NH1,
    NH2,
    P12,
    P12v1,
    P12v2,
    P18,
    P19,
    P6,
    P6v1,
    P6v2,
    P6v3,
    P6v4,
    P99,
    Q1,
    Q2,
    Q2v1,
    Q2v2,
    Q4,
    Q4v1,
    Q5,
    Q6,
    Q6v1,
    R1,
    R12,
    R12v1,
    R2,
    R2v1,
    R2v2,
    R4,
    REX,
    REXv1,
    REXv2,
    REXv3,
    REXv4,
    S1,
    S2,
    S2v1,
    S35,
    S4,
    S41,
    S80,
    S80v1,
    S80v2,
    S9,
    S9v1,
    S91,
    S91v1,
    SH99,
    T14,
    T14v1,
    T18,
    T18v1,
    T2,
    U4,
    U4v1,
    U4v2,
    U5,
    U6,
    U6v1,
    U6v2,
    U7,
    U7v1,
    U7v2,
    U7v3,
    U7v4,
    V1,
    V12,
    V14,
    V14v1,
    V2,
    V2v1,
    V4,
    V4v1,
    V7,
    V8,
    W1,
    W14,
    W14v1,
    W14v2,
    W2,
    W2v1,
    W2v2,
    W2v3,
    W2v4,
    W2v5,
    W2v6,
    W2v7,
    W3,
    W3v1,
    W4,
    W4v1,
    W4v2,
    W45,
    W47,
    W5,
    W6,
    W6v1,
    W8,
    W8v1,
    W8v2,
    X1,
    X2,
    X2v1,
    X2v2,
    X2v3,
    X3,
    X3v1,
    X8,
    X9,
    X9v1,
    X9v2,
    Y2,
    Y7,
    Y8,
    Z11,
    Z11v1,
    Z2,
    Z2v1,
    Z2v2,
    Z2v3,
    Z6,
    Z6v1,
    Z6v2,
    Z7,
    Z7v1,
    Z8,
    Z8v1,
    Z8v2,
    Z8v3,
    Z8v4,
    Z8v5,
    Z8v6,
}

impl Route {
    pub fn new(s: &str) -> Result<Self, StringIsNotRouteError> {
        s.parse()
    }
}

impl Fetch for Route {}

impl NeedsRoute for Route {}

// Overwrite NeedsRoute methods
impl Route {
    /// Bus positions for this route around a given lat/long.
    /// [WMATA Documentation](https://developer.wmata.com/docs/services/54763629281d83086473f231/operations/5476362a281d830c946a3d68?)
    ///
    /// # Example
    /// ```
    /// use wmata::{Route, RadiusAtLatLong};
    /// use tokio_test::block_on;
    ///
    /// let route = Route::A2;
    /// let positions = block_on(async {
    ///     route.positions(
    ///         Some(RadiusAtLatLong::new(1000, 38.8817596, -77.0166426)),
    ///         "9e38c3eab34c4e6c990828002828f5ed"
    ///     ).await
    /// });
    ///
    /// assert!(positions.is_ok());
    /// ```
    pub async fn positions(
        self,
        radius_at_lat_long: Option<RadiusAtLatLong>,
        api_key: &str,
    ) -> Result<responses::BusPositions, Error> {
        self.positions_along(Some(self), radius_at_lat_long, api_key)
            .await
    }

    /// Reported bus incidents/delays for this route.
    /// [WMATA Documentation](https://developer.wmata.com/docs/services/54763641281d83086473f232/operations/54763641281d830c946a3d75)
    ///
    /// # Examples
    /// ```
    /// use wmata::Route;
    /// use tokio_test::block_on;
    ///
    /// let incidents = block_on(async { Route::A2.incidents("9e38c3eab34c4e6c990828002828f5ed").await });
    /// assert!(incidents.is_ok());
    /// ```
    pub async fn incidents(self, api_key: &str) -> Result<responses::Incidents, Error> {
        self.incidents_along(Some(self), api_key).await
    }

    /// For an optional given date, returns the set of ordered latitude/longitude
    /// points along this route along with the list of stops served.
    /// [WMATA Documentation](https://developer.wmata.com/docs/services/54763629281d83086473f231/operations/5476362a281d830c946a3d69?)
    ///
    /// # Date
    /// Omit date for current date
    ///
    /// # Examples
    /// ```
    /// use wmata::Route;
    /// use tokio_test::block_on;
    ///
    /// let path = block_on(async { Route::A2.path(None, "9e38c3eab34c4e6c990828002828f5ed").await });
    /// assert!(path.is_ok());
    /// ```
    /// With a date
    /// ```
    /// use wmata::{Route, Date};
    /// use tokio_test::block_on;
    ///
    /// let path = block_on(async { Route::A2.path(Some(Date::new(2019, 10, 2)), "9e38c3eab34c4e6c990828002828f5ed").await });
    /// assert!(path.is_ok());
    /// ```
    pub async fn path(
        self,
        date: Option<Date>,
        api_key: &str,
    ) -> Result<responses::PathDetails, Error> {
        <Self as NeedsRoute>::path(&self, self, date, api_key).await
    }

    /// Schedules for this route for an optional given date.
    /// [WMATA Documentation](https://developer.wmata.com/docs/services/54763629281d83086473f231/operations/5476362a281d830c946a3d6b?)
    ///
    /// # Date
    /// Omit date for current date
    ///
    /// # Variations
    /// Whether or not to include variations if a base route is specified in Route.
    /// For example, if B30 is specified and IncludingVariations is set to true,
    /// data for all variations of B30 such as B30v1, B30v2, etc. will be returned.
    ///
    /// # Examples
    /// ```
    /// use wmata::Route;
    /// use tokio_test::block_on;
    ///
    /// let schedule = block_on(async { Route::A2.schedule(None, false, "9e38c3eab34c4e6c990828002828f5ed").await });
    /// assert!(schedule.is_ok());
    /// ```
    ///
    /// with date and variations
    /// ```
    /// use wmata::{Route, Date};
    /// use tokio_test::block_on;
    ///
    /// let schedule = block_on(async { Route::A2.schedule(Some(Date::new(2019, 10, 2)), true, "9e38c3eab34c4e6c990828002828f5ed").await });
    /// assert!(schedule.is_ok());
    /// ```
    pub async fn schedule(
        self,
        date: Option<Date>,
        including_variations: bool,
        api_key: &str,
    ) -> Result<responses::RouteSchedule, Error> {
        self.route_schedule(self, date, including_variations, api_key)
            .await
    }
}

impl<'de> Deserialize<'de> for Route {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let route = String::deserialize(deserializer)?;

        Route::from_str(&route).map_err(SerdeError::custom)
    }
}

impl ToString for Route {
    fn to_string(&self) -> String {
        match self {
            Route::One0A => "10A".to_string(),
            Route::One0B => "10B".to_string(),
            Route::One0E => "10E".to_string(),
            Route::One0N => "10N".to_string(),
            Route::One1Y => "11Y".to_string(),
            Route::One1Yv1 => "11Yv1".to_string(),
            Route::One1Yv2 => "11Yv2".to_string(),
            Route::One5K => "15K".to_string(),
            Route::One5Kv1 => "15Kv1".to_string(),
            Route::One6A => "16A".to_string(),
            Route::One6C => "16C".to_string(),
            Route::One6Cv1 => "16Cv1".to_string(),
            Route::One6E => "16E".to_string(),
            Route::One6G => "16G".to_string(),
            Route::One6Gv1 => "16Gv1".to_string(),
            Route::One6H => "16H".to_string(),
            Route::One6L => "16L".to_string(),
            Route::One6Y => "16Y".to_string(),
            Route::One6Yv1 => "16Yv1".to_string(),
            Route::One7B => "17B".to_string(),
            Route::One7G => "17G".to_string(),
            Route::One7H => "17H".to_string(),
            Route::One7K => "17K".to_string(),
            Route::One7L => "17L".to_string(),
            Route::One7M => "17M".to_string(),
            Route::One8G => "18G".to_string(),
            Route::One8H => "18H".to_string(),
            Route::One8J => "18J".to_string(),
            Route::One8P => "18P".to_string(),
            Route::One8Pv1 => "18Pv1".to_string(),
            Route::One8Pv2 => "18Pv2".to_string(),
            Route::OneA => "1A".to_string(),
            Route::OneB => "1B".to_string(),
            Route::OneC => "1C".to_string(),
            Route::OneCv1 => "1Cv1".to_string(),
            Route::OneCv2 => "1Cv2".to_string(),
            Route::OneCv3 => "1Cv3".to_string(),
            Route::OneCv4 => "1Cv4".to_string(),
            Route::Two1A => "21A".to_string(),
            Route::Two1D => "21D".to_string(),
            Route::Two2A => "22A".to_string(),
            Route::Two2Av1 => "22Av1".to_string(),
            Route::Two2C => "22C".to_string(),
            Route::Two2F => "22F".to_string(),
            Route::Two3A => "23A".to_string(),
            Route::Two3B => "23B".to_string(),
            Route::Two3Bv1 => "23Bv1".to_string(),
            Route::Two3T => "23T".to_string(),
            Route::Two5B => "25B".to_string(),
            Route::Two5Bv1 => "25Bv1".to_string(),
            Route::Two5Bv2 => "25Bv2".to_string(),
            Route::Two5Bv3 => "25Bv3".to_string(),
            Route::Two6A => "26A".to_string(),
            Route::Two8A => "28A".to_string(),
            Route::Two8Av1 => "28Av1".to_string(),
            Route::Two8F => "28F".to_string(),
            Route::Two8G => "28G".to_string(),
            Route::Two9C => "29C".to_string(),
            Route::Two9G => "29G".to_string(),
            Route::Two9K => "29K".to_string(),
            Route::Two9Kv1 => "29Kv1".to_string(),
            Route::Two9N => "29N".to_string(),
            Route::Two9Nv1 => "29Nv1".to_string(),
            Route::Two9W => "29W".to_string(),
            Route::TwoA => "2A".to_string(),
            Route::TwoB => "2B".to_string(),
            Route::TwoBv1 => "2Bv1".to_string(),
            Route::TwoBv2 => "2Bv2".to_string(),
            Route::TwoBv3 => "2Bv3".to_string(),
            Route::Three0N => "30N".to_string(),
            Route::Three0S => "30S".to_string(),
            Route::Three1 => "31".to_string(),
            Route::Three2 => "32".to_string(),
            Route::Three2v1 => "32v1".to_string(),
            Route::Three3 => "33".to_string(),
            Route::Three4 => "34".to_string(),
            Route::Three6 => "36".to_string(),
            Route::Three7 => "37".to_string(),
            Route::Three8B => "38B".to_string(),
            Route::Three8Bv1 => "38Bv1".to_string(),
            Route::Three8Bv2 => "38Bv2".to_string(),
            Route::Three9 => "39".to_string(),
            Route::ThreeA => "3A".to_string(),
            Route::ThreeAv1 => "3Av1".to_string(),
            Route::ThreeT => "3T".to_string(),
            Route::ThreeTv1 => "3Tv1".to_string(),
            Route::ThreeY => "3Y".to_string(),
            Route::Four2 => "42".to_string(),
            Route::Four3 => "43".to_string(),
            Route::FourA => "4A".to_string(),
            Route::FourB => "4B".to_string(),
            Route::Five2 => "52".to_string(),
            Route::Five2v1 => "52v1".to_string(),
            Route::Five2v2 => "52v2".to_string(),
            Route::Five4 => "54".to_string(),
            Route::Five4v1 => "54v1".to_string(),
            Route::Five4v2 => "54v2".to_string(),
            Route::Five4v3 => "54v3".to_string(),
            Route::Five9 => "59".to_string(),
            Route::FiveA => "5A".to_string(),
            Route::Six0 => "60".to_string(),
            Route::Six2 => "62".to_string(),
            Route::Six2v1 => "62v1".to_string(),
            Route::Six3 => "63".to_string(),
            Route::Six4 => "64".to_string(),
            Route::Six4v1 => "64v1".to_string(),
            Route::Seven0 => "70".to_string(),
            Route::Seven0v1 => "70v1".to_string(),
            Route::Seven4 => "74".to_string(),
            Route::Seven9 => "79".to_string(),
            Route::SevenA => "7A".to_string(),
            Route::SevenAv1 => "7Av1".to_string(),
            Route::SevenAv2 => "7Av2".to_string(),
            Route::SevenAv3 => "7Av3".to_string(),
            Route::SevenC => "7C".to_string(),
            Route::SevenF => "7F".to_string(),
            Route::SevenFv1 => "7Fv1".to_string(),
            Route::SevenM => "7M".to_string(),
            Route::SevenMv1 => "7Mv1".to_string(),
            Route::SevenP => "7P".to_string(),
            Route::SevenW => "7W".to_string(),
            Route::SevenY => "7Y".to_string(),
            Route::SevenYv1 => "7Yv1".to_string(),
            Route::Eight0 => "80".to_string(),
            Route::Eight0v1 => "80v1".to_string(),
            Route::Eight0v2 => "80v2".to_string(),
            Route::Eight0v3 => "80v3".to_string(),
            Route::Eight3 => "83".to_string(),
            Route::Eight3v1 => "83v1".to_string(),
            Route::Eight3v2 => "83v2".to_string(),
            Route::Eight3v3 => "83v3".to_string(),
            Route::Eight3v4 => "83v4".to_string(),
            Route::Eight6 => "86".to_string(),
            Route::Eight6v1 => "86v1".to_string(),
            Route::Eight6v2 => "86v2".to_string(),
            Route::Eight7 => "87".to_string(),
            Route::Eight7v1 => "87v1".to_string(),
            Route::Eight7v2 => "87v2".to_string(),
            Route::Eight7v3 => "87v3".to_string(),
            Route::Eight7v4 => "87v4".to_string(),
            Route::Eight7v5 => "87v5".to_string(),
            Route::Eight9 => "89".to_string(),
            Route::Eight9v1 => "89v1".to_string(),
            Route::Eight9M => "89M".to_string(),
            Route::EightS => "8S".to_string(),
            Route::EightW => "8W".to_string(),
            Route::EightZ => "8Z".to_string(),
            Route::Nine0 => "90".to_string(),
            Route::Nine0v1 => "90v1".to_string(),
            Route::Nine0v2 => "90v2".to_string(),
            Route::Nine2 => "92".to_string(),
            Route::Nine2v1 => "92v1".to_string(),
            Route::Nine2v2 => "92v2".to_string(),
            Route::Nine6 => "96".to_string(),
            Route::Nine6v1 => "96v1".to_string(),
            Route::Nine6v2 => "96v2".to_string(),
            Route::Nine6v3 => "96v3".to_string(),
            Route::Nine6v4 => "96v4".to_string(),
            Route::Nine6v5 => "96v5".to_string(),
            Route::Nine7 => "97".to_string(),
            Route::Nine7v1 => "97v1".to_string(),
            Route::A12 => "A12".to_string(),
            Route::A12v1 => "A12v1".to_string(),
            Route::A12v2 => "A12v2".to_string(),
            Route::A12v3 => "A12v3".to_string(),
            Route::A2 => "A2".to_string(),
            Route::A2v1 => "A2v1".to_string(),
            Route::A2v2 => "A2v2".to_string(),
            Route::A2v3 => "A2v3".to_string(),
            Route::A31 => "A31".to_string(),
            Route::A32 => "A32".to_string(),
            Route::A33 => "A33".to_string(),
            Route::A4 => "A4".to_string(),
            Route::A4v1 => "A4v1".to_string(),
            Route::A4v2 => "A4v2".to_string(),
            Route::A4v3 => "A4v3".to_string(),
            Route::A4v4 => "A4v4".to_string(),
            Route::A4v5 => "A4v5".to_string(),
            Route::A6 => "A6".to_string(),
            Route::A6v1 => "A6v1".to_string(),
            Route::A7 => "A7".to_string(),
            Route::A8 => "A8".to_string(),
            Route::A8v1 => "A8v1".to_string(),
            Route::A9 => "A9".to_string(),
            Route::B2 => "B2".to_string(),
            Route::B2v1 => "B2v1".to_string(),
            Route::B2v2 => "B2v2".to_string(),
            Route::B2v3 => "B2v3".to_string(),
            Route::B2v4 => "B2v4".to_string(),
            Route::B21 => "B21".to_string(),
            Route::B22 => "B22".to_string(),
            Route::B22v1 => "B22v1".to_string(),
            Route::B24 => "B24".to_string(),
            Route::B24v1 => "B24v1".to_string(),
            Route::B27 => "B27".to_string(),
            Route::B29 => "B29".to_string(),
            Route::B29v1 => "B29v1".to_string(),
            Route::B29v2 => "B29v2".to_string(),
            Route::B30 => "B30".to_string(),
            Route::B8 => "B8".to_string(),
            Route::B8v1 => "B8v1".to_string(),
            Route::B8v2 => "B8v2".to_string(),
            Route::B9 => "B9".to_string(),
            Route::B98 => "B98".to_string(),
            Route::B99 => "B99".to_string(),
            Route::C11 => "C11".to_string(),
            Route::C12 => "C12".to_string(),
            Route::C13 => "C13".to_string(),
            Route::C14 => "C14".to_string(),
            Route::C2 => "C2".to_string(),
            Route::C2v1 => "C2v1".to_string(),
            Route::C2v2 => "C2v2".to_string(),
            Route::C2v3 => "C2v3".to_string(),
            Route::C21 => "C21".to_string(),
            Route::C21v1 => "C21v1".to_string(),
            Route::C21v2 => "C21v2".to_string(),
            Route::C22 => "C22".to_string(),
            Route::C22v1 => "C22v1".to_string(),
            Route::C26 => "C26".to_string(),
            Route::C26v1 => "C26v1".to_string(),
            Route::C28 => "C28".to_string(),
            Route::C28v1 => "C28v1".to_string(),
            Route::C29 => "C29".to_string(),
            Route::C29_1 => "C29*1".to_string(),
            Route::C29_2 => "C29*2".to_string(),
            Route::C29_4 => "C29*4".to_string(),
            Route::C290 => "C29/".to_string(),
            Route::C4 => "C4".to_string(),
            Route::C4v1 => "C4v1".to_string(),
            Route::C4v2 => "C4v2".to_string(),
            Route::C4v3 => "C4v3".to_string(),
            Route::C8 => "C8".to_string(),
            Route::C8v1 => "C8v1".to_string(),
            Route::C8v2 => "C8v2".to_string(),
            Route::C8v3 => "C8v3".to_string(),
            Route::D1 => "D1".to_string(),
            Route::D12 => "D12".to_string(),
            Route::D12v1 => "D12v1".to_string(),
            Route::D12v2 => "D12v2".to_string(),
            Route::D13 => "D13".to_string(),
            Route::D13v1 => "D13v1".to_string(),
            Route::D14 => "D14".to_string(),
            Route::D14v1 => "D14v1".to_string(),
            Route::D14v2 => "D14v2".to_string(),
            Route::D2 => "D2".to_string(),
            Route::D2v1 => "D2v1".to_string(),
            Route::D31 => "D31".to_string(),
            Route::D32 => "D32".to_string(),
            Route::D33 => "D33".to_string(),
            Route::D34 => "D34".to_string(),
            Route::D4 => "D4".to_string(),
            Route::D4v1 => "D4v1".to_string(),
            Route::D4v2 => "D4v2".to_string(),
            Route::D5 => "D5".to_string(),
            Route::D51 => "D51".to_string(),
            Route::D6 => "D6".to_string(),
            Route::D6v1 => "D6v1".to_string(),
            Route::D6v2 => "D6v2".to_string(),
            Route::D6v3 => "D6v3".to_string(),
            Route::D8 => "D8".to_string(),
            Route::D8v1 => "D8v1".to_string(),
            Route::E2 => "E2".to_string(),
            Route::E4 => "E4".to_string(),
            Route::E4v1 => "E4v1".to_string(),
            Route::E4v2 => "E4v2".to_string(),
            Route::E6 => "E6".to_string(),
            Route::F1 => "F1".to_string(),
            Route::F12 => "F12".to_string(),
            Route::F12v1 => "F12v1".to_string(),
            Route::F13 => "F13".to_string(),
            Route::F13v1 => "F13v1".to_string(),
            Route::F13v2 => "F13v2".to_string(),
            Route::F13v3 => "F13v3".to_string(),
            Route::F14 => "F14".to_string(),
            Route::F14v1 => "F14v1".to_string(),
            Route::F2 => "F2".to_string(),
            Route::F2v1 => "F2v1".to_string(),
            Route::F2v2 => "F2v2".to_string(),
            Route::F4 => "F4".to_string(),
            Route::F4v1 => "F4v1".to_string(),
            Route::F4v2 => "F4v2".to_string(),
            Route::F6 => "F6".to_string(),
            Route::F6v1 => "F6v1".to_string(),
            Route::F6v2 => "F6v2".to_string(),
            Route::F8 => "F8".to_string(),
            Route::F99 => "F99".to_string(),
            Route::G12 => "G12".to_string(),
            Route::G12v1 => "G12v1".to_string(),
            Route::G12v2 => "G12v2".to_string(),
            Route::G14 => "G14".to_string(),
            Route::G14v1 => "G14v1".to_string(),
            Route::G14v2 => "G14v2".to_string(),
            Route::G2 => "G2".to_string(),
            Route::G2v1 => "G2v1".to_string(),
            Route::G8 => "G8".to_string(),
            Route::G8v1 => "G8v1".to_string(),
            Route::G8v2 => "G8v2".to_string(),
            Route::G8v3 => "G8v3".to_string(),
            Route::G9 => "G9".to_string(),
            Route::G9v1 => "G9v1".to_string(),
            Route::H1 => "H1".to_string(),
            Route::H11 => "H11".to_string(),
            Route::H12 => "H12".to_string(),
            Route::H12v1 => "H12v1".to_string(),
            Route::H13 => "H13".to_string(),
            Route::H2 => "H2".to_string(),
            Route::H3 => "H3".to_string(),
            Route::H4 => "H4".to_string(),
            Route::H4v1 => "H4v1".to_string(),
            Route::H6 => "H6".to_string(),
            Route::H6v1 => "H6v1".to_string(),
            Route::H8 => "H8".to_string(),
            Route::H9 => "H9".to_string(),
            Route::J1 => "J1".to_string(),
            Route::J1v1 => "J1v1".to_string(),
            Route::J12 => "J12".to_string(),
            Route::J12v1 => "J12v1".to_string(),
            Route::J2 => "J2".to_string(),
            Route::J2v1 => "J2v1".to_string(),
            Route::J2v2 => "J2v2".to_string(),
            Route::J4 => "J4".to_string(),
            Route::K12 => "K12".to_string(),
            Route::K12v1 => "K12v1".to_string(),
            Route::K12v2 => "K12v2".to_string(),
            Route::K2 => "K2".to_string(),
            Route::K6 => "K6".to_string(),
            Route::K6v1 => "K6v1".to_string(),
            Route::K9 => "K9".to_string(),
            Route::K9v1 => "K9v1".to_string(),
            Route::L1 => "L1".to_string(),
            Route::L2 => "L2".to_string(),
            Route::L2v1 => "L2v1".to_string(),
            Route::L2v2 => "L2v2".to_string(),
            Route::L99 => "L99".to_string(),
            Route::L8 => "L8".to_string(),
            Route::M4 => "M4".to_string(),
            Route::M4v1 => "M4v1".to_string(),
            Route::M4v2 => "M4v2".to_string(),
            Route::M6 => "M6".to_string(),
            Route::M6v1 => "M6v1".to_string(),
            Route::MW1 => "MW1".to_string(),
            Route::M99 => "M99".to_string(),
            Route::N2 => "N2".to_string(),
            Route::N4 => "N4".to_string(),
            Route::N4v1 => "N4v1".to_string(),
            Route::N6 => "N6".to_string(),
            Route::NH1 => "NH1".to_string(),
            Route::NH2 => "NH2".to_string(),
            Route::P12 => "P12".to_string(),
            Route::P12v1 => "P12v1".to_string(),
            Route::P12v2 => "P12v2".to_string(),
            Route::P18 => "P18".to_string(),
            Route::P19 => "P19".to_string(),
            Route::P6 => "P6".to_string(),
            Route::P6v1 => "P6v1".to_string(),
            Route::P6v2 => "P6v2".to_string(),
            Route::P6v3 => "P6v3".to_string(),
            Route::P6v4 => "P6v4".to_string(),
            Route::P99 => "P99".to_string(),
            Route::Q1 => "Q1".to_string(),
            Route::Q2 => "Q2".to_string(),
            Route::Q2v1 => "Q2v1".to_string(),
            Route::Q2v2 => "Q2v2".to_string(),
            Route::Q4 => "Q4".to_string(),
            Route::Q4v1 => "Q4v1".to_string(),
            Route::Q5 => "Q5".to_string(),
            Route::Q6 => "Q6".to_string(),
            Route::Q6v1 => "Q6v1".to_string(),
            Route::R1 => "R1".to_string(),
            Route::R12 => "R12".to_string(),
            Route::R12v1 => "R12v1".to_string(),
            Route::R2 => "R2".to_string(),
            Route::R2v1 => "R2v1".to_string(),
            Route::R2v2 => "R2v2".to_string(),
            Route::R4 => "R4".to_string(),
            Route::REX => "REX".to_string(),
            Route::REXv1 => "REXv1".to_string(),
            Route::REXv2 => "REXv2".to_string(),
            Route::REXv3 => "REXv3".to_string(),
            Route::REXv4 => "REXv4".to_string(),
            Route::S1 => "S1".to_string(),
            Route::S2 => "S2".to_string(),
            Route::S2v1 => "S2v1".to_string(),
            Route::S35 => "S35".to_string(),
            Route::S4 => "S4".to_string(),
            Route::S41 => "S41".to_string(),
            Route::S80 => "S80".to_string(),
            Route::S80v1 => "S80v1".to_string(),
            Route::S80v2 => "S80v2".to_string(),
            Route::S9 => "S9".to_string(),
            Route::S9v1 => "S9v1".to_string(),
            Route::S91 => "S91".to_string(),
            Route::S91v1 => "S91v1".to_string(),
            Route::SH99 => "SH99".to_string(),
            Route::T14 => "T14".to_string(),
            Route::T14v1 => "T14v1".to_string(),
            Route::T18 => "T18".to_string(),
            Route::T18v1 => "T18v1".to_string(),
            Route::T2 => "T2".to_string(),
            Route::U4 => "U4".to_string(),
            Route::U4v1 => "U4v1".to_string(),
            Route::U4v2 => "U4v2".to_string(),
            Route::U5 => "U5".to_string(),
            Route::U6 => "U6".to_string(),
            Route::U6v1 => "U6v1".to_string(),
            Route::U6v2 => "U6v2".to_string(),
            Route::U7 => "U7".to_string(),
            Route::U7v1 => "U7v1".to_string(),
            Route::U7v2 => "U7v2".to_string(),
            Route::U7v3 => "U7v3".to_string(),
            Route::U7v4 => "U7v4".to_string(),
            Route::V1 => "V1".to_string(),
            Route::V12 => "V12".to_string(),
            Route::V14 => "V14".to_string(),
            Route::V14v1 => "V14v1".to_string(),
            Route::V2 => "V2".to_string(),
            Route::V2v1 => "V2v1".to_string(),
            Route::V4 => "V4".to_string(),
            Route::V4v1 => "V4v1".to_string(),
            Route::V7 => "V7".to_string(),
            Route::V8 => "V8".to_string(),
            Route::W1 => "W1".to_string(),
            Route::W14 => "W14".to_string(),
            Route::W14v1 => "W14v1".to_string(),
            Route::W14v2 => "W14v2".to_string(),
            Route::W2 => "W2".to_string(),
            Route::W2v1 => "W2v1".to_string(),
            Route::W2v2 => "W2v2".to_string(),
            Route::W2v3 => "W2v3".to_string(),
            Route::W2v4 => "W2v4".to_string(),
            Route::W2v5 => "W2v5".to_string(),
            Route::W2v6 => "W2v6".to_string(),
            Route::W2v7 => "W2v7".to_string(),
            Route::W3 => "W3".to_string(),
            Route::W3v1 => "W3v1".to_string(),
            Route::W4 => "W4".to_string(),
            Route::W4v1 => "W4v1".to_string(),
            Route::W4v2 => "W4v2".to_string(),
            Route::W45 => "W45".to_string(),
            Route::W47 => "W47".to_string(),
            Route::W5 => "W5".to_string(),
            Route::W6 => "W6".to_string(),
            Route::W6v1 => "W6v1".to_string(),
            Route::W8 => "W8".to_string(),
            Route::W8v1 => "W8v1".to_string(),
            Route::W8v2 => "W8v2".to_string(),
            Route::X1 => "X1".to_string(),
            Route::X2 => "X2".to_string(),
            Route::X2v1 => "X2v1".to_string(),
            Route::X2v2 => "X2v2".to_string(),
            Route::X2v3 => "X2v3".to_string(),
            Route::X3 => "X3".to_string(),
            Route::X3v1 => "X3v1".to_string(),
            Route::X8 => "X8".to_string(),
            Route::X9 => "X9".to_string(),
            Route::X9v1 => "X9v1".to_string(),
            Route::X9v2 => "X9v2".to_string(),
            Route::Y2 => "Y2".to_string(),
            Route::Y7 => "Y7".to_string(),
            Route::Y8 => "Y8".to_string(),
            Route::Z11 => "Z11".to_string(),
            Route::Z11v1 => "Z11v1".to_string(),
            Route::Z2 => "Z2".to_string(),
            Route::Z2v1 => "Z2v1".to_string(),
            Route::Z2v2 => "Z2v2".to_string(),
            Route::Z2v3 => "Z2v3".to_string(),
            Route::Z6 => "Z6".to_string(),
            Route::Z6v1 => "Z6v1".to_string(),
            Route::Z6v2 => "Z6v2".to_string(),
            Route::Z7 => "Z7".to_string(),
            Route::Z7v1 => "Z7v1".to_string(),
            Route::Z8 => "Z8".to_string(),
            Route::Z8v1 => "Z8v1".to_string(),
            Route::Z8v2 => "Z8v2".to_string(),
            Route::Z8v3 => "Z8v3".to_string(),
            Route::Z8v4 => "Z8v4".to_string(),
            Route::Z8v5 => "Z8v5".to_string(),
            Route::Z8v6 => "Z8v6".to_string(),
        }
    }
}

impl FromStr for Route {
    type Err = StringIsNotRouteError;

    /// Convert a string into a Route.
    ///
    /// # Examples
    /// ```
    /// use wmata::Route;
    ///
    /// let route_id: Route = "10A".parse().unwrap();
    ///
    /// assert_eq!(route_id, Route::One0A);
    /// ```
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "10A" => Ok(Route::One0A),
            "10B" => Ok(Route::One0B),
            "10E" => Ok(Route::One0E),
            "10N" => Ok(Route::One0N),
            "11Y" => Ok(Route::One1Y),
            "11Yv1" => Ok(Route::One1Yv1),
            "11Yv2" => Ok(Route::One1Yv2),
            "15K" => Ok(Route::One5K),
            "15Kv1" => Ok(Route::One5Kv1),
            "16A" => Ok(Route::One6A),
            "16C" => Ok(Route::One6C),
            "16Cv1" => Ok(Route::One6Cv1),
            "16E" => Ok(Route::One6E),
            "16G" => Ok(Route::One6G),
            "16Gv1" => Ok(Route::One6Gv1),
            "16H" => Ok(Route::One6H),
            "16L" => Ok(Route::One6L),
            "16Y" => Ok(Route::One6Y),
            "16Yv1" => Ok(Route::One6Yv1),
            "17B" => Ok(Route::One7B),
            "17G" => Ok(Route::One7G),
            "17H" => Ok(Route::One7H),
            "17K" => Ok(Route::One7K),
            "17L" => Ok(Route::One7L),
            "17M" => Ok(Route::One7M),
            "18G" => Ok(Route::One8G),
            "18H" => Ok(Route::One8H),
            "18J" => Ok(Route::One8J),
            "18P" => Ok(Route::One8P),
            "18Pv1" => Ok(Route::One8Pv1),
            "18Pv2" => Ok(Route::One8Pv2),
            "1A" => Ok(Route::OneA),
            "1B" => Ok(Route::OneB),
            "1C" => Ok(Route::OneC),
            "1Cv1" => Ok(Route::OneCv1),
            "1Cv2" => Ok(Route::OneCv2),
            "1Cv3" => Ok(Route::OneCv3),
            "1Cv4" => Ok(Route::OneCv4),
            "21A" => Ok(Route::Two1A),
            "21D" => Ok(Route::Two1D),
            "22A" => Ok(Route::Two2A),
            "22Av1" => Ok(Route::Two2Av1),
            "22C" => Ok(Route::Two2C),
            "22F" => Ok(Route::Two2F),
            "23A" => Ok(Route::Two3A),
            "23B" => Ok(Route::Two3B),
            "23Bv1" => Ok(Route::Two3Bv1),
            "23T" => Ok(Route::Two3T),
            "25B" => Ok(Route::Two5B),
            "25Bv1" => Ok(Route::Two5Bv1),
            "25Bv2" => Ok(Route::Two5Bv2),
            "25Bv3" => Ok(Route::Two5Bv3),
            "26A" => Ok(Route::Two6A),
            "28A" => Ok(Route::Two8A),
            "28Av1" => Ok(Route::Two8Av1),
            "28F" => Ok(Route::Two8F),
            "28G" => Ok(Route::Two8G),
            "29C" => Ok(Route::Two9C),
            "29G" => Ok(Route::Two9G),
            "29K" => Ok(Route::Two9K),
            "29Kv1" => Ok(Route::Two9Kv1),
            "29N" => Ok(Route::Two9N),
            "29Nv1" => Ok(Route::Two9Nv1),
            "29W" => Ok(Route::Two9W),
            "2A" => Ok(Route::TwoA),
            "2B" => Ok(Route::TwoB),
            "2Bv1" => Ok(Route::TwoBv1),
            "2Bv2" => Ok(Route::TwoBv2),
            "2Bv3" => Ok(Route::TwoBv3),
            "30N" => Ok(Route::Three0N),
            "30S" => Ok(Route::Three0S),
            "31" => Ok(Route::Three1),
            "32" => Ok(Route::Three2),
            "32v1" => Ok(Route::Three2v1),
            "33" => Ok(Route::Three3),
            "34" => Ok(Route::Three4),
            "36" => Ok(Route::Three6),
            "37" => Ok(Route::Three7),
            "38B" => Ok(Route::Three8B),
            "38Bv1" => Ok(Route::Three8Bv1),
            "38Bv2" => Ok(Route::Three8Bv2),
            "39" => Ok(Route::Three9),
            "3A" => Ok(Route::ThreeA),
            "3Av1" => Ok(Route::ThreeAv1),
            "3T" => Ok(Route::ThreeT),
            "3Tv1" => Ok(Route::ThreeTv1),
            "3Y" => Ok(Route::ThreeY),
            "42" => Ok(Route::Four2),
            "43" => Ok(Route::Four3),
            "4A" => Ok(Route::FourA),
            "4B" => Ok(Route::FourB),
            "52" => Ok(Route::Five2),
            "52v1" => Ok(Route::Five2v1),
            "52v2" => Ok(Route::Five2v2),
            "54" => Ok(Route::Five4),
            "54v1" => Ok(Route::Five4v1),
            "54v2" => Ok(Route::Five4v2),
            "54v3" => Ok(Route::Five4v3),
            "59" => Ok(Route::Five9),
            "5A" => Ok(Route::FiveA),
            "60" => Ok(Route::Six0),
            "62" => Ok(Route::Six2),
            "62v1" => Ok(Route::Six2v1),
            "63" => Ok(Route::Six3),
            "64" => Ok(Route::Six4),
            "64v1" => Ok(Route::Six4v1),
            "70" => Ok(Route::Seven0),
            "70v1" => Ok(Route::Seven0v1),
            "74" => Ok(Route::Seven4),
            "79" => Ok(Route::Seven9),
            "7A" => Ok(Route::SevenA),
            "7Av1" => Ok(Route::SevenAv1),
            "7Av2" => Ok(Route::SevenAv2),
            "7Av3" => Ok(Route::SevenAv3),
            "7C" => Ok(Route::SevenC),
            "7F" => Ok(Route::SevenF),
            "7Fv1" => Ok(Route::SevenFv1),
            "7M" => Ok(Route::SevenM),
            "7Mv1" => Ok(Route::SevenMv1),
            "7P" => Ok(Route::SevenP),
            "7W" => Ok(Route::SevenW),
            "7Y" => Ok(Route::SevenY),
            "7Yv1" => Ok(Route::SevenYv1),
            "80" => Ok(Route::Eight0),
            "80v1" => Ok(Route::Eight0v1),
            "80v2" => Ok(Route::Eight0v2),
            "80v3" => Ok(Route::Eight0v3),
            "83" => Ok(Route::Eight3),
            "83v1" => Ok(Route::Eight3v1),
            "83v2" => Ok(Route::Eight3v2),
            "83v3" => Ok(Route::Eight3v3),
            "83v4" => Ok(Route::Eight3v4),
            "86" => Ok(Route::Eight6),
            "86v1" => Ok(Route::Eight6v1),
            "86v2" => Ok(Route::Eight6v2),
            "87" => Ok(Route::Eight7),
            "87v1" => Ok(Route::Eight7v1),
            "87v2" => Ok(Route::Eight7v2),
            "87v3" => Ok(Route::Eight7v3),
            "87v4" => Ok(Route::Eight7v4),
            "87v5" => Ok(Route::Eight7v5),
            "89" => Ok(Route::Eight9),
            "89v1" => Ok(Route::Eight9v1),
            "89M" => Ok(Route::Eight9M),
            "8S" => Ok(Route::EightS),
            "8W" => Ok(Route::EightW),
            "8Z" => Ok(Route::EightZ),
            "90" => Ok(Route::Nine0),
            "90v1" => Ok(Route::Nine0v1),
            "90v2" => Ok(Route::Nine0v2),
            "92" => Ok(Route::Nine2),
            "92v1" => Ok(Route::Nine2v1),
            "92v2" => Ok(Route::Nine2v2),
            "96" => Ok(Route::Nine6),
            "96v1" => Ok(Route::Nine6v1),
            "96v2" => Ok(Route::Nine6v2),
            "96v3" => Ok(Route::Nine6v3),
            "96v4" => Ok(Route::Nine6v4),
            "96v5" => Ok(Route::Nine6v5),
            "97" => Ok(Route::Nine7),
            "97v1" => Ok(Route::Nine7v1),
            "A12" => Ok(Route::A12),
            "A12v1" => Ok(Route::A12v1),
            "A12v2" => Ok(Route::A12v2),
            "A12v3" => Ok(Route::A12v3),
            "A2" => Ok(Route::A2),
            "A2v1" => Ok(Route::A2v1),
            "A2v2" => Ok(Route::A2v2),
            "A2v3" => Ok(Route::A2v3),
            "A31" => Ok(Route::A31),
            "A32" => Ok(Route::A32),
            "A33" => Ok(Route::A33),
            "A4" => Ok(Route::A4),
            "A4v1" => Ok(Route::A4v1),
            "A4v2" => Ok(Route::A4v2),
            "A4v3" => Ok(Route::A4v3),
            "A4v4" => Ok(Route::A4v4),
            "A4v5" => Ok(Route::A4v5),
            "A6" => Ok(Route::A6),
            "A6v1" => Ok(Route::A6v1),
            "A7" => Ok(Route::A7),
            "A8" => Ok(Route::A8),
            "A8v1" => Ok(Route::A8v1),
            "A9" => Ok(Route::A9),
            "B2" => Ok(Route::B2),
            "B2v1" => Ok(Route::B2v1),
            "B2v2" => Ok(Route::B2v2),
            "B2v3" => Ok(Route::B2v3),
            "B2v4" => Ok(Route::B2v4),
            "B21" => Ok(Route::B21),
            "B22" => Ok(Route::B22),
            "B22v1" => Ok(Route::B22v1),
            "B24" => Ok(Route::B24),
            "B24v1" => Ok(Route::B24v1),
            "B27" => Ok(Route::B27),
            "B29" => Ok(Route::B29),
            "B29v1" => Ok(Route::B29v1),
            "B29v2" => Ok(Route::B29v2),
            "B30" => Ok(Route::B30),
            "B8" => Ok(Route::B8),
            "B8v1" => Ok(Route::B8v1),
            "B8v2" => Ok(Route::B8v2),
            "B9" => Ok(Route::B9),
            "B98" => Ok(Route::B98),
            "B99" => Ok(Route::B99),
            "C11" => Ok(Route::C11),
            "C12" => Ok(Route::C12),
            "C13" => Ok(Route::C13),
            "C14" => Ok(Route::C14),
            "C2" => Ok(Route::C2),
            "C2v1" => Ok(Route::C2v1),
            "C2v2" => Ok(Route::C2v2),
            "C2v3" => Ok(Route::C2v3),
            "C21" => Ok(Route::C21),
            "C21v1" => Ok(Route::C21v1),
            "C21v2" => Ok(Route::C21v2),
            "C22" => Ok(Route::C22),
            "C22v1" => Ok(Route::C22v1),
            "C26" => Ok(Route::C26),
            "C26v1" => Ok(Route::C26v1),
            "C28" => Ok(Route::C28),
            "C29" => Ok(Route::C29),
            "C28v1" => Ok(Route::C28v1),
            "C29*1" => Ok(Route::C29_1),
            "C29*2" => Ok(Route::C29_2),
            "C29*4" => Ok(Route::C29_4),
            "C29/" => Ok(Route::C290),
            "C4" => Ok(Route::C4),
            "C4v1" => Ok(Route::C4v1),
            "C4v2" => Ok(Route::C4v2),
            "C4v3" => Ok(Route::C4v3),
            "C8" => Ok(Route::C8),
            "C8v1" => Ok(Route::C8v1),
            "C8v2" => Ok(Route::C8v2),
            "C8v3" => Ok(Route::C8v3),
            "D1" => Ok(Route::D1),
            "D12" => Ok(Route::D12),
            "D12v1" => Ok(Route::D12v1),
            "D12v2" => Ok(Route::D12v2),
            "D13" => Ok(Route::D13),
            "D13v1" => Ok(Route::D13v1),
            "D14" => Ok(Route::D14),
            "D14v1" => Ok(Route::D14v1),
            "D14v2" => Ok(Route::D14v2),
            "D2" => Ok(Route::D2),
            "D2v1" => Ok(Route::D2v1),
            "D31" => Ok(Route::D31),
            "D32" => Ok(Route::D32),
            "D33" => Ok(Route::D33),
            "D34" => Ok(Route::D34),
            "D4" => Ok(Route::D4),
            "D4v1" => Ok(Route::D4v1),
            "D4v2" => Ok(Route::D4v2),
            "D5" => Ok(Route::D5),
            "D51" => Ok(Route::D51),
            "D6" => Ok(Route::D6),
            "D6v1" => Ok(Route::D6v1),
            "D6v2" => Ok(Route::D6v2),
            "D6v3" => Ok(Route::D6v3),
            "D8" => Ok(Route::D8),
            "D8v1" => Ok(Route::D8v1),
            "E2" => Ok(Route::E2),
            "E4" => Ok(Route::E4),
            "E4v1" => Ok(Route::E4v1),
            "E4v2" => Ok(Route::E4v2),
            "E6" => Ok(Route::E6),
            "F1" => Ok(Route::F1),
            "F12" => Ok(Route::F12),
            "F12v1" => Ok(Route::F12v1),
            "F13" => Ok(Route::F13),
            "F13v1" => Ok(Route::F13v1),
            "F13v2" => Ok(Route::F13v2),
            "F13v3" => Ok(Route::F13v3),
            "F14" => Ok(Route::F14),
            "F14v1" => Ok(Route::F14v1),
            "F2" => Ok(Route::F2),
            "F2v1" => Ok(Route::F2v1),
            "F2v2" => Ok(Route::F2v2),
            "F4" => Ok(Route::F4),
            "F4v1" => Ok(Route::F4v1),
            "F4v2" => Ok(Route::F4v2),
            "F6" => Ok(Route::F6),
            "F6v1" => Ok(Route::F6v1),
            "F6v2" => Ok(Route::F6v2),
            "F8" => Ok(Route::F8),
            "F99" => Ok(Route::F99),
            "G12" => Ok(Route::G12),
            "G12v1" => Ok(Route::G12v1),
            "G12v2" => Ok(Route::G12v2),
            "G14" => Ok(Route::G14),
            "G14v1" => Ok(Route::G14v1),
            "G14v2" => Ok(Route::G14v2),
            "G2" => Ok(Route::G2),
            "G2v1" => Ok(Route::G2v1),
            "G8" => Ok(Route::G8),
            "G8v1" => Ok(Route::G8v1),
            "G8v2" => Ok(Route::G8v2),
            "G8v3" => Ok(Route::G8v3),
            "G9" => Ok(Route::G9),
            "G9v1" => Ok(Route::G9v1),
            "H1" => Ok(Route::H1),
            "H11" => Ok(Route::H11),
            "H12" => Ok(Route::H12),
            "H12v1" => Ok(Route::H12v1),
            "H13" => Ok(Route::H13),
            "H2" => Ok(Route::H2),
            "H3" => Ok(Route::H3),
            "H4" => Ok(Route::H4),
            "H4v1" => Ok(Route::H4v1),
            "H6" => Ok(Route::H6),
            "H6v1" => Ok(Route::H6v1),
            "H8" => Ok(Route::H8),
            "H9" => Ok(Route::H9),
            "J1" => Ok(Route::J1),
            "J1v1" => Ok(Route::J1v1),
            "J12" => Ok(Route::J12),
            "J12v1" => Ok(Route::J12v1),
            "J2" => Ok(Route::J2),
            "J2v1" => Ok(Route::J2v1),
            "J2v2" => Ok(Route::J2v2),
            "J4" => Ok(Route::J4),
            "K12" => Ok(Route::K12),
            "K12v1" => Ok(Route::K12v1),
            "K12v2" => Ok(Route::K12v2),
            "K2" => Ok(Route::K2),
            "K6" => Ok(Route::K6),
            "K6v1" => Ok(Route::K6v1),
            "K9" => Ok(Route::K9),
            "K9v1" => Ok(Route::K9v1),
            "L1" => Ok(Route::L1),
            "L2" => Ok(Route::L2),
            "L2v1" => Ok(Route::L2v1),
            "L2v2" => Ok(Route::L2v2),
            "L8" => Ok(Route::L8),
            "L99" => Ok(Route::L99),
            "M4" => Ok(Route::M4),
            "M4v1" => Ok(Route::M4v1),
            "M4v2" => Ok(Route::M4v2),
            "M6" => Ok(Route::M6),
            "M6v1" => Ok(Route::M6v1),
            "MW1" => Ok(Route::MW1),
            "M99" => Ok(Route::M99),
            "N2" => Ok(Route::N2),
            "N4" => Ok(Route::N4),
            "N4v1" => Ok(Route::N4v1),
            "N6" => Ok(Route::N6),
            "NH1" => Ok(Route::NH1),
            "NH2" => Ok(Route::NH2),
            "P12" => Ok(Route::P12),
            "P12v1" => Ok(Route::P12v1),
            "P12v2" => Ok(Route::P12v2),
            "P18" => Ok(Route::P18),
            "P19" => Ok(Route::P19),
            "P6" => Ok(Route::P6),
            "P6v1" => Ok(Route::P6v1),
            "P6v2" => Ok(Route::P6v2),
            "P6v3" => Ok(Route::P6v3),
            "P6v4" => Ok(Route::P6v4),
            "P99" => Ok(Route::P99),
            "Q1" => Ok(Route::Q1),
            "Q2" => Ok(Route::Q2),
            "Q2v1" => Ok(Route::Q2v1),
            "Q2v2" => Ok(Route::Q2v2),
            "Q4" => Ok(Route::Q4),
            "Q4v1" => Ok(Route::Q4v1),
            "Q5" => Ok(Route::Q5),
            "Q6" => Ok(Route::Q6),
            "Q6v1" => Ok(Route::Q6v1),
            "R1" => Ok(Route::R1),
            "R12" => Ok(Route::R12),
            "R12v1" => Ok(Route::R12v1),
            "R2" => Ok(Route::R2),
            "R2v1" => Ok(Route::R2v1),
            "R2v2" => Ok(Route::R2v2),
            "R4" => Ok(Route::R4),
            "REX" => Ok(Route::REX),
            "REXv1" => Ok(Route::REXv1),
            "REXv2" => Ok(Route::REXv2),
            "REXv3" => Ok(Route::REXv3),
            "REXv4" => Ok(Route::REXv4),
            "S1" => Ok(Route::S1),
            "S2" => Ok(Route::S2),
            "S2v1" => Ok(Route::S2v1),
            "S35" => Ok(Route::S35),
            "S4" => Ok(Route::S4),
            "S41" => Ok(Route::S41),
            "S80" => Ok(Route::S80),
            "S80v1" => Ok(Route::S80v1),
            "S80v2" => Ok(Route::S80v2),
            "S9" => Ok(Route::S9),
            "S9v1" => Ok(Route::S9v1),
            "S91" => Ok(Route::S91),
            "S91v1" => Ok(Route::S91v1),
            "SH99" => Ok(Route::SH99),
            "T14" => Ok(Route::T14),
            "T14v1" => Ok(Route::T14v1),
            "T18" => Ok(Route::T18),
            "T18v1" => Ok(Route::T18v1),
            "T2" => Ok(Route::T2),
            "U4" => Ok(Route::U4),
            "U4v1" => Ok(Route::U4v1),
            "U4v2" => Ok(Route::U4v2),
            "U5" => Ok(Route::U5),
            "U6" => Ok(Route::U6),
            "U6v1" => Ok(Route::U6v1),
            "U6v2" => Ok(Route::U6v2),
            "U7" => Ok(Route::U7),
            "U7v1" => Ok(Route::U7v1),
            "U7v2" => Ok(Route::U7v2),
            "U7v3" => Ok(Route::U7v3),
            "U7v4" => Ok(Route::U7v4),
            "V1" => Ok(Route::V1),
            "V12" => Ok(Route::V12),
            "V14" => Ok(Route::V14),
            "V14v1" => Ok(Route::V14v1),
            "V2" => Ok(Route::V2),
            "V2v1" => Ok(Route::V2v1),
            "V4" => Ok(Route::V4),
            "V4v1" => Ok(Route::V4v1),
            "V7" => Ok(Route::V7),
            "V8" => Ok(Route::V8),
            "W1" => Ok(Route::W1),
            "W14" => Ok(Route::W14),
            "W14v1" => Ok(Route::W14v1),
            "W14v2" => Ok(Route::W14v2),
            "W2" => Ok(Route::W2),
            "W2v1" => Ok(Route::W2v1),
            "W2v2" => Ok(Route::W2v2),
            "W2v3" => Ok(Route::W2v3),
            "W2v4" => Ok(Route::W2v4),
            "W2v5" => Ok(Route::W2v5),
            "W2v6" => Ok(Route::W2v6),
            "W2v7" => Ok(Route::W2v7),
            "W3" => Ok(Route::W3),
            "W3v1" => Ok(Route::W3v1),
            "W4" => Ok(Route::W4),
            "W4v1" => Ok(Route::W4v1),
            "W4v2" => Ok(Route::W4v2),
            "W45" => Ok(Route::W45),
            "W47" => Ok(Route::W47),
            "W5" => Ok(Route::W5),
            "W6" => Ok(Route::W6),
            "W6v1" => Ok(Route::W6v1),
            "W8" => Ok(Route::W8),
            "W8v1" => Ok(Route::W8v1),
            "W8v2" => Ok(Route::W8v2),
            "X1" => Ok(Route::X1),
            "X2" => Ok(Route::X2),
            "X2v1" => Ok(Route::X2v1),
            "X2v2" => Ok(Route::X2v2),
            "X2v3" => Ok(Route::X2v3),
            "X3" => Ok(Route::X3),
            "X3v1" => Ok(Route::X3v1),
            "X8" => Ok(Route::X8),
            "X9" => Ok(Route::X9),
            "X9v1" => Ok(Route::X9v1),
            "X9v2" => Ok(Route::X9v2),
            "Y2" => Ok(Route::Y2),
            "Y7" => Ok(Route::Y7),
            "Y8" => Ok(Route::Y8),
            "Z11" => Ok(Route::Z11),
            "Z11v1" => Ok(Route::Z11v1),
            "Z2" => Ok(Route::Z2),
            "Z2v1" => Ok(Route::Z2v1),
            "Z2v2" => Ok(Route::Z2v2),
            "Z2v3" => Ok(Route::Z2v3),
            "Z6" => Ok(Route::Z6),
            "Z6v1" => Ok(Route::Z6v1),
            "Z6v2" => Ok(Route::Z6v2),
            "Z7" => Ok(Route::Z7),
            "Z7v1" => Ok(Route::Z7v1),
            "Z8" => Ok(Route::Z8),
            "Z8v1" => Ok(Route::Z8v1),
            "Z8v2" => Ok(Route::Z8v2),
            "Z8v3" => Ok(Route::Z8v3),
            "Z8v4" => Ok(Route::Z8v4),
            "Z8v5" => Ok(Route::Z8v5),
            "Z8v6" => Ok(Route::Z8v6),
            _ => Err(StringIsNotRouteError(s.to_string())),
        }
    }
}

#[derive(Debug, Clone)]
pub struct StringIsNotRouteError(pub String);

impl fmt::Display for StringIsNotRouteError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{} is not a valid Route ID.", self.0)
    }
}

impl error::Error for StringIsNotRouteError {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        None
    }
}