gtfs_structures/
enums.rs

1use serde::de::{Deserialize, Deserializer};
2use serde::ser::{Serialize, Serializer};
3
4/// All the objects type from the GTFS specification that this library reads
5#[derive(Debug, Serialize, Eq, PartialEq, Hash)]
6pub enum ObjectType {
7    /// [crate::Agency] <https://gtfs.org/reference/static/#agencytxt>
8    Agency,
9    /// [crate::Stop] <https://gtfs.org/reference/static/#stopstxt>
10    Stop,
11    /// [crate::Route] <https://gtfs.org/reference/static/#routestxt>
12    Route,
13    /// [crate::Trip] <https://gtfs.org/reference/static/#tripstxt>
14    Trip,
15    /// [crate::Calendar] <https://gtfs.org/reference/static/#calendartxt>
16    Calendar,
17    /// [crate::Shape] <https://gtfs.org/reference/static/#shapestxt>
18    Shape,
19    /// [crate::FareAttribute] <https://gtfs.org/reference/static/#fare_rulestxt>
20    Fare,
21    /// [crate::Pathway] <https://gtfs.org/schedule/reference/#pathwaystxt>
22    Pathway,
23}
24
25/// Describes the kind of [crate::Stop]. See <https://gtfs.org/reference/static/#stopstxt> `location_type`
26#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
27pub enum LocationType {
28    /// Stop (or Platform). A location where passengers board or disembark from a transit vehicle. Is called a platform when defined within a parent_station
29    #[default]
30    StopPoint,
31    /// Station. A physical structure or area that contains one or more platform
32    StopArea,
33    /// A location where passengers can enter or exit a station from the street. If an entrance/exit belongs to multiple stations, it can be linked by pathways to both, but the data provider must pick one of them as parent
34    StationEntrance,
35    /// A location within a station, not matching any other [crate::Stop::location_type], which can be used to link together pathways define in pathways.txt.
36    GenericNode,
37    /// A specific location on a platform, where passengers can board and/or alight vehicles
38    BoardingArea,
39    /// An unknown value
40    Unknown(i16),
41}
42
43fn serialize_i16_as_str<S: Serializer>(s: S, value: i16) -> Result<S::Ok, S::Error> {
44    s.serialize_str(&value.to_string())
45}
46impl<'de> Deserialize<'de> for LocationType {
47    fn deserialize<D>(deserializer: D) -> Result<LocationType, D::Error>
48    where
49        D: Deserializer<'de>,
50    {
51        let s = <&str>::deserialize(deserializer)?;
52        Ok(match s {
53            "" | "0" => LocationType::StopPoint,
54            "1" => LocationType::StopArea,
55            "2" => LocationType::StationEntrance,
56            "3" => LocationType::GenericNode,
57            "4" => LocationType::BoardingArea,
58            s => LocationType::Unknown(s.parse().map_err(|_| {
59                serde::de::Error::custom(format!(
60                    "invalid value for LocationType, must be an integer: {s}"
61                ))
62            })?),
63        })
64    }
65}
66
67impl Serialize for LocationType {
68    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
69    where
70        S: Serializer,
71    {
72        // Note: for extended route type, we might loose the initial precise route type
73        serialize_i16_as_str(
74            serializer,
75            match self {
76                LocationType::StopPoint => 0,
77                LocationType::StopArea => 1,
78                LocationType::StationEntrance => 2,
79                LocationType::GenericNode => 3,
80                LocationType::BoardingArea => 4,
81                LocationType::Unknown(i) => *i,
82            },
83        )
84    }
85}
86
87#[derive(Debug, Clone, derive_more::TryFrom, Copy, PartialEq, Eq, Hash)]
88#[repr(i16)]
89#[try_from(repr)]
90/// Google Transit extended route types [https://developers.google.com/transit/gtfs/reference/extended-route-types](https://developers.google.com/transit/gtfs/reference/extended-route-types)
91pub enum ExtendedRouteType {
92    /// Railway Service.
93    Railway = 100,
94    /// High Speed Rail Service. Examples: TGV (FR), ICE (DE), Eurostar (GB).
95    HighSpeedRail = 101,
96    /// Long Distance Trains. Examples: InterCity/EuroCity.
97    LongDistanceTrains = 102,
98    /// Inter Regional Rail Service. Examples: InterRegio (DE), Cross County Rail (GB).
99    InterRegionalRail = 103,
100    /// Car Transport Rail Service.
101    CarTransportRail = 104,
102    /// Sleeper Rail Service. Example: GNER Sleeper (GB).
103    SleeperRail = 105,
104    /// Regional Rail Service. Examples: TER (FR), Regionalzug (DE).
105    RegionalRail = 106,
106    /// Tourist Railway Service. Example: Romney, Hythe & Dymchurch (GB).
107    TouristRailway = 107,
108    /// Rail Shuttle (Within Complex). Examples: Gatwick Shuttle (GB), Sky Line (DE).
109    RailShuttleWithinComplex = 108,
110    /// Suburban Railway. Examples: S-Bahn (DE), RER (FR), S-tog (Kopenhagen).
111    SuburbanRailway = 109,
112    /// Replacement Rail Service.
113    ReplacementRail = 110,
114    /// Special Rail Service.
115    SpecialRail = 111,
116    /// Lorry Transport Rail Service.
117    LorryTransportRail = 112,
118    /// All Rail Services.
119    OtherRail = 113,
120    /// Cross-Country Rail Service.
121    CrossCountryRail = 114,
122    /// Vehicle Transport Rail Service.
123    VehicleTransportRail = 115,
124    /// Rack and Pinion Railway. Examples: Rochers de Naye (CH), Dolderbahn (CH).
125    RackAndPinionRailway = 116,
126    /// Additional Rail Service.
127    AdditionalRail = 117,
128
129    /// Coach Service.
130    Coach = 200,
131    /// International Coach Service. Examples: EuroLine, Touring.
132    InternationalCoach = 201,
133    /// National Coach Service. Example: National Express (GB).
134    NationalCoach = 202,
135    /// Shuttle Coach Service. Examples: Roissy Bus (FR), Reading-Heathrow (GB).
136    ShuttleCoach = 203,
137    /// Regional Coach Service.
138    RegionalCoach = 204,
139    /// Special Coach Service.
140    SpecialCoach = 205,
141    /// Sightseeing Coach Service.
142    SightseeingCoach = 206,
143    /// Tourist Coach Service.
144    TouristCoach = 207,
145    /// Commuter Coach Service.
146    CommuterCoach = 208,
147    /// All Coach Services.
148    OtherCoach = 209,
149
150    /// Urban Railway Service.
151    UrbanRailway = 400,
152    /// Metro Service. Example: Métro de Paris.
153    Metro = 401,
154    /// Underground Service. Examples: London Underground, U-Bahn.
155    Underground = 402,
156    /// Urban Railway Service.
157    UrbanRailwayServiceDetail = 403,
158    /// All Urban Railway Services.
159    OtherUrbanRailway = 404,
160    /// Monorail.
161    Monorail = 405,
162
163    /// Bus Service.
164    Bus = 700,
165    /// Regional Bus Service. Example: Eastbourne-Maidstone (GB).
166    RegionalBus = 701,
167    /// Express Bus Service. Example: X19 Wokingham-Heathrow (GB).
168    ExpressBus = 702,
169    /// Stopping Bus Service. Example: 38 London: Clapton Pond-Victoria (GB).
170    StoppingBus = 703,
171    /// Local Bus Service.
172    LocalBus = 704,
173    /// Night Bus Service. Example: N prefixed buses in London (GB).
174    NightBus = 705,
175    /// Post Bus Service. Example: Maidstone P4 (GB).
176    PostBus = 706,
177    /// Special Needs Bus.
178    SpecialNeedsBus = 707,
179    /// Mobility Bus Service.
180    MobilityBus = 708,
181    /// Mobility Bus for Registered Disabled.
182    MobilityBusForRegisteredDisabled = 709,
183    /// Sightseeing Bus.
184    SightseeingBus = 710,
185    /// Shuttle Bus. Example: 747 Heathrow-Gatwick Airport Service (GB).
186    ShuttleBus = 711,
187    /// School Bus.
188    SchoolBus = 712,
189    /// School and Public Service Bus.
190    SchoolAndPublicServiceBus = 713,
191    /// Rail Replacement Bus Service.
192    RailReplacementBus = 714,
193    /// Demand and Response Bus Service.
194    DemandAndResponseBus = 715,
195    /// All Bus Services.
196    OtherBus = 716,
197
198    /// Trolleybus Service.
199    Trolleybus = 800,
200
201    /// Tram Service.
202    Tram = 900,
203    /// City Tram Service.
204    CityTram = 901,
205    /// Local Tram Service. Examples: Munich (DE), Brussels (BE), Croydon (GB).
206    LocalTram = 902,
207    /// Regional Tram Service.
208    RegionalTram = 903,
209    /// Sightseeing Tram Service. Example: Blackpool Seafront (GB).
210    SightseeingTram = 904,
211    /// Shuttle Tram Service.
212    ShuttleTram = 905,
213    /// All Tram Services.
214    OtherTram = 906,
215
216    /// Water Transport Service.
217    WaterTransport = 1000,
218    /// Air Service.
219    Air = 1100,
220    /// Ferry Service.
221    Ferry = 1200,
222
223    /// Aerial Lift Service. Examples: Telefèric de Montjuïc (ES), Saleve (CH), Roosevelt Island Tramway (US).
224    AerialLift = 1300,
225    /// Telecabin Service.
226    Telecabin = 1301,
227    /// Cable Car Service.
228    CableCar = 1302,
229    /// Elevator Service.
230    Elevator = 1303,
231    /// Chair Lift Service.
232    ChairLift = 1304,
233    /// Drag Lift Service.
234    DragLift = 1305,
235    /// Small Telecabin Service.
236    SmallTelecabin = 1306,
237    /// All Telecabin Services.
238    OtherTelecabin = 1307,
239
240    // Funicular Service
241    /// Funicular Service. Example: Rigiblick (Zürich, CH).
242    Funicular = 1400,
243
244    /// Taxi Service.
245    Taxi = 1500,
246    /// Communal Taxi Service. Examples: Marshrutka (RU), dolmuş (TR).
247    CommunalTaxi = 1501,
248    /// Water Taxi Service.
249    WaterTaxi = 1502,
250    /// Rail Taxi Service.
251    RailTaxi = 1503,
252    /// Bike Taxi Service.
253    BikeTaxi = 1504,
254    /// Licensed Taxi Service.
255    LicensedTaxi = 1505,
256    /// Private Hire Service Vehicle.
257    PrivateHireServiceVehicle = 1506,
258    /// All Taxi Services.
259    OtherTaxi = 1507,
260
261    /// Miscellaneous Service.
262    MiscellaneousService = 1700,
263    /// Horse-drawn Carriage.
264    HorseDrawnCarriage = 1702,
265}
266
267/// Describes the kind of [crate::Route]. See <https://gtfs.org/reference/static/#routestxt> `route_type`
268///
269/// Some route types are extended GTFS (<https://developers.google.com/transit/gtfs/reference/extended-route-types)>
270#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
271pub enum RouteType {
272    /// Tram, Streetcar, Light rail. Any light rail or street level system within a metropolitan area
273    Tramway,
274    /// Subway, Metro. Any underground rail system within a metropolitan area.
275    Subway,
276    /// Used for intercity or long-distance travel
277    Rail,
278    /// Used for short- and long-distance bus routes
279    #[default]
280    Bus,
281    /// Used for short- and long-distance boat service
282    Ferry,
283    /// Used for street-level rail cars where the cable runs beneath the vehicle, e.g., cable car in San Francisco
284    CableCar,
285    /// Aerial lift, suspended cable car (e.g., gondola lift, aerial tramway). Cable transport where cabins, cars, gondolas or open chairs are suspended by means of one or more cables
286    Gondola,
287    /// Any rail system designed for steep inclines
288    Funicular,
289    /// Google Transit extended route types <https://developers.google.com/transit/gtfs/reference/extended-route-types>
290    Extended(ExtendedRouteType),
291    /// Any other value
292    Other(i16),
293}
294
295impl ExtendedRouteType {
296    /// Convert extended route types to standard route types if possible. All route types that can not be represented in standard route types at all are kept as-is.
297    /// This loses precision.
298    pub fn to_standard_route_type(&self) -> RouteType {
299        let int = *self as i16;
300        let hundreds = int / 100;
301        match hundreds {
302            1 => RouteType::Rail,
303            4 => RouteType::Subway,
304            2 | 7 | 8 => RouteType::Bus,
305            9 => RouteType::Tramway,
306            10 | 12 => RouteType::Ferry,
307            13 => RouteType::Gondola,
308            14 => RouteType::Funicular,
309            _ => RouteType::Extended(*self),
310        }
311    }
312}
313
314impl<'de> Deserialize<'de> for RouteType {
315    fn deserialize<D>(deserializer: D) -> Result<RouteType, D::Error>
316    where
317        D: Deserializer<'de>,
318    {
319        let i = i16::deserialize(deserializer)?;
320        if let Ok(ert) = ExtendedRouteType::try_from(i) {
321            return Ok(RouteType::Extended(ert));
322        }
323
324        Ok(match i {
325            0 => RouteType::Tramway,
326            1 => RouteType::Subway,
327            2 => RouteType::Rail,
328            3 => RouteType::Bus,
329            4 => RouteType::Ferry,
330            5 => RouteType::CableCar,
331            6 => RouteType::Gondola,
332            7 => RouteType::Funicular,
333            _ => RouteType::Other(i),
334        })
335    }
336}
337
338impl Serialize for RouteType {
339    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
340    where
341        S: Serializer,
342    {
343        serializer.serialize_i16(match self {
344            RouteType::Tramway => 0,
345            RouteType::Subway => 1,
346            RouteType::Rail => 2,
347            RouteType::Bus => 3,
348            RouteType::Ferry => 4,
349            RouteType::CableCar => 5,
350            RouteType::Gondola => 6,
351            RouteType::Funicular => 7,
352            RouteType::Extended(ert) => *ert as i16,
353            RouteType::Other(i) => *i,
354        })
355    }
356}
357
358/// Describes if and how a traveller can board or alight the vehicle. See <https://gtfs.org/reference/static/#stop_timestxt> `pickup_type` and `dropoff_type`
359#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
360pub enum PickupDropOffType {
361    /// Regularly scheduled pickup or drop off (default when empty).
362    #[default]
363    Regular,
364    /// No pickup or drop off available.
365    NotAvailable,
366    /// Must phone agency to arrange pickup or drop off.
367    ArrangeByPhone,
368    /// Must coordinate with driver to arrange pickup or drop off.
369    CoordinateWithDriver,
370    /// An unknown value not in the specification
371    Unknown(i16),
372}
373
374impl<'de> Deserialize<'de> for PickupDropOffType {
375    fn deserialize<D>(deserializer: D) -> Result<PickupDropOffType, D::Error>
376    where
377        D: Deserializer<'de>,
378    {
379        let s = <&str>::deserialize(deserializer)?;
380        Ok(match s {
381            "" | "0" => PickupDropOffType::Regular,
382            "1" => PickupDropOffType::NotAvailable,
383            "2" => PickupDropOffType::ArrangeByPhone,
384            "3" => PickupDropOffType::CoordinateWithDriver,
385            s => PickupDropOffType::Unknown(s.parse().map_err(|_| {
386                serde::de::Error::custom(format!(
387                    "invalid value for PickupDropOffType, must be an integer: {s}"
388                ))
389            })?),
390        })
391    }
392}
393
394impl Serialize for PickupDropOffType {
395    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
396    where
397        S: Serializer,
398    {
399        // Note: for extended route type, we might loose the initial precise route type
400        serialize_i16_as_str(
401            serializer,
402            match self {
403                PickupDropOffType::Regular => 0,
404                PickupDropOffType::NotAvailable => 1,
405                PickupDropOffType::ArrangeByPhone => 2,
406                PickupDropOffType::CoordinateWithDriver => 3,
407                PickupDropOffType::Unknown(i) => *i,
408            },
409        )
410    }
411}
412
413/// Indicates whether a rider can board the transit vehicle anywhere along the vehicle’s travel path
414///
415/// Those values are only defined on <https://developers.google.com/transit/gtfs/reference#routestxt,> not on <https://gtfs.org/reference/static/#routestxt>
416#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
417pub enum ContinuousPickupDropOff {
418    /// Continuous stopping pickup or drop off.
419    Continuous,
420    /// No continuous stopping pickup or drop off (default when empty).
421    #[default]
422    NotAvailable,
423    /// Must phone agency to arrange continuous stopping pickup or drop off.
424    ArrangeByPhone,
425    /// Must coordinate with driver to arrange continuous stopping pickup or drop off.
426    CoordinateWithDriver,
427    /// An unknown value not in the specification
428    Unknown(i16),
429}
430
431impl Serialize for ContinuousPickupDropOff {
432    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
433    where
434        S: Serializer,
435    {
436        // Note: for extended route type, we might loose the initial precise route type
437        serialize_i16_as_str(
438            serializer,
439            match self {
440                ContinuousPickupDropOff::Continuous => 0,
441                ContinuousPickupDropOff::NotAvailable => 1,
442                ContinuousPickupDropOff::ArrangeByPhone => 2,
443                ContinuousPickupDropOff::CoordinateWithDriver => 3,
444                ContinuousPickupDropOff::Unknown(i) => *i,
445            },
446        )
447    }
448}
449
450impl<'de> Deserialize<'de> for ContinuousPickupDropOff {
451    fn deserialize<D>(deserializer: D) -> Result<ContinuousPickupDropOff, D::Error>
452    where
453        D: Deserializer<'de>,
454    {
455        let s = <&str>::deserialize(deserializer)?;
456        Ok(match s {
457            "0" => ContinuousPickupDropOff::Continuous,
458            "" | "1" => ContinuousPickupDropOff::NotAvailable,
459            "2" => ContinuousPickupDropOff::ArrangeByPhone,
460            "3" => ContinuousPickupDropOff::CoordinateWithDriver,
461            s => ContinuousPickupDropOff::Unknown(s.parse().map_err(|_| {
462                serde::de::Error::custom(format!(
463                    "invalid value for ContinuousPickupDropOff, must be an integer: {s}"
464                ))
465            })?),
466        })
467    }
468}
469
470/// Describes if the stop time is exact or not. See <https://gtfs.org/reference/static/#stop_timestxt> `timepoint`
471#[derive(Debug, Default, Serialize, Copy, Clone, PartialEq, Eq, Hash)]
472pub enum TimepointType {
473    /// Times are considered approximate
474    #[serde(rename = "0")]
475    Approximate = 0,
476    /// Times are considered exact
477    #[default]
478    #[serde(rename = "1")]
479    Exact = 1,
480}
481
482impl<'de> Deserialize<'de> for TimepointType {
483    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
484    where
485        D: Deserializer<'de>,
486    {
487        let s = <&str>::deserialize(deserializer)?;
488        match s {
489            "" | "1" => Ok(Self::Exact),
490            "0" => Ok(Self::Approximate),
491            v => Err(serde::de::Error::custom(format!(
492                "invalid value for timepoint: {v}"
493            ))),
494        }
495    }
496}
497
498/// Generic enum to define if a service (like wheelchair boarding) is available
499#[derive(Debug, Default, PartialEq, Eq, Hash, Clone, Copy)]
500pub enum Availability {
501    /// No information if the service is available
502    #[default]
503    InformationNotAvailable,
504    /// The service is available
505    Available,
506    /// The service is not available
507    NotAvailable,
508    /// An unknown value not in the specification
509    Unknown(i16),
510}
511
512impl<'de> Deserialize<'de> for Availability {
513    fn deserialize<D>(deserializer: D) -> Result<Availability, D::Error>
514    where
515        D: Deserializer<'de>,
516    {
517        let s = <&str>::deserialize(deserializer)?;
518        Ok(match s {
519            "" | "0" => Availability::InformationNotAvailable,
520            "1" => Availability::Available,
521            "2" => Availability::NotAvailable,
522            s => Availability::Unknown(s.parse().map_err(|_| {
523                serde::de::Error::custom(format!(
524                    "invalid value for Availability, must be an integer: {s}"
525                ))
526            })?),
527        })
528    }
529}
530
531impl Serialize for Availability {
532    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
533    where
534        S: Serializer,
535    {
536        // Note: for extended route type, we might loose the initial precise route type
537        serialize_i16_as_str(
538            serializer,
539            match self {
540                Availability::InformationNotAvailable => 0,
541                Availability::Available => 1,
542                Availability::NotAvailable => 2,
543                Availability::Unknown(i) => *i,
544            },
545        )
546    }
547}
548
549/// Defines if a [crate::CalendarDate] is added or deleted from a [crate::Calendar]
550#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Hash, Clone, Copy)]
551pub enum Exception {
552    /// There will be a service on that day
553    #[serde(rename = "1")]
554    Added,
555    /// There won’t be a service on that day
556    #[serde(rename = "2")]
557    Deleted,
558}
559
560/// Defines the direction of a [crate::Trip], only for display, not for routing. See <https://gtfs.org/reference/static/#tripstxt> `direction_id`
561#[derive(Debug, Deserialize, Serialize, Copy, Clone, PartialEq, Eq, Hash)]
562pub enum DirectionType {
563    /// Travel in one direction (e.g. outbound travel).
564    #[serde(rename = "0")]
565    Outbound,
566    /// Travel in the opposite direction (e.g. inbound travel).
567    #[serde(rename = "1")]
568    Inbound,
569}
570
571/// Is the [crate::Trip] accessible with a bike. See <https://gtfs.org/reference/static/#tripstxt> `bikes_allowed`
572#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
573pub enum BikesAllowedType {
574    /// No bike information for the trip
575    #[default]
576    NoBikeInfo,
577    /// Vehicle being used on this particular trip can accommodate at least one bicycle
578    AtLeastOneBike,
579    /// No bicycles are allowed on this trip
580    NoBikesAllowed,
581    /// An unknown value not in the specification
582    Unknown(i16),
583}
584
585impl<'de> Deserialize<'de> for BikesAllowedType {
586    fn deserialize<D>(deserializer: D) -> Result<BikesAllowedType, D::Error>
587    where
588        D: Deserializer<'de>,
589    {
590        let s = <&str>::deserialize(deserializer)?;
591        Ok(match s {
592            "" | "0" => BikesAllowedType::NoBikeInfo,
593            "1" => BikesAllowedType::AtLeastOneBike,
594            "2" => BikesAllowedType::NoBikesAllowed,
595            s => BikesAllowedType::Unknown(s.parse().map_err(|_| {
596                serde::de::Error::custom(format!(
597                    "invalid value for BikeAllowedType, must be an integer: {s}"
598                ))
599            })?),
600        })
601    }
602}
603
604impl Serialize for BikesAllowedType {
605    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
606    where
607        S: Serializer,
608    {
609        // Note: for extended route type, we might loose the initial precise route type
610        serialize_i16_as_str(
611            serializer,
612            match self {
613                BikesAllowedType::NoBikeInfo => 0,
614                BikesAllowedType::AtLeastOneBike => 1,
615                BikesAllowedType::NoBikesAllowed => 2,
616                BikesAllowedType::Unknown(i) => *i,
617            },
618        )
619    }
620}
621
622/// Is the [crate::Trip] accessible with a car. See <https://gtfs.org/reference/static/#tripstxt> `bikes_allowed`
623#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
624pub enum CarsAllowedType {
625    /// No car transport information for the trip
626    #[default]
627    NoCarInfo,
628    /// Vehicle being used on this particular trip can accommodate at least one car
629    AtLeastOneCar,
630    /// No cars are allowed on this trip
631    NoCarsAllowed,
632    /// An unknown value not in the specification
633    Unknown(i16),
634}
635
636impl<'de> Deserialize<'de> for CarsAllowedType {
637    fn deserialize<D>(deserializer: D) -> Result<CarsAllowedType, D::Error>
638    where
639        D: Deserializer<'de>,
640    {
641        let s = <&str>::deserialize(deserializer)?;
642        Ok(match s {
643            "" | "0" => CarsAllowedType::NoCarInfo,
644            "1" => CarsAllowedType::AtLeastOneCar,
645            "2" => CarsAllowedType::NoCarsAllowed,
646            s => CarsAllowedType::Unknown(s.parse().map_err(|_| {
647                serde::de::Error::custom(format!(
648                    "invalid value for CarsAllowedType, must be an integer: {s}"
649                ))
650            })?),
651        })
652    }
653}
654
655impl Serialize for CarsAllowedType {
656    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
657    where
658        S: Serializer,
659    {
660        // Note: for extended route type, we might loose the initial precise route type
661        serialize_i16_as_str(
662            serializer,
663            match self {
664                CarsAllowedType::NoCarInfo => 0,
665                CarsAllowedType::AtLeastOneCar => 1,
666                CarsAllowedType::NoCarsAllowed => 2,
667                CarsAllowedType::Unknown(i) => *i,
668            },
669        )
670    }
671}
672/// Defines where a [crate::FareAttribute] can be paid
673#[derive(Debug, Deserialize, Serialize, Copy, Clone, PartialEq, Eq)]
674pub enum PaymentMethod {
675    /// Fare is paid on board
676    #[serde(rename = "0")]
677    Aboard,
678    /// Fare must be paid before boarding
679    #[serde(rename = "1")]
680    PreBoarding,
681}
682
683/// Defines if the [crate::Frequency] is exact (the vehicle runs exactly every n minutes) or not
684#[derive(Debug, Serialize, Copy, Clone, PartialEq, Eq, Hash)]
685pub enum ExactTimes {
686    /// Frequency-based trips
687    FrequencyBased = 0,
688    /// Schedule-based trips with the exact same headway throughout the day.
689    ScheduleBased = 1,
690}
691
692impl<'de> Deserialize<'de> for ExactTimes {
693    fn deserialize<D>(deserializer: D) -> Result<ExactTimes, D::Error>
694    where
695        D: Deserializer<'de>,
696    {
697        let s = <&str>::deserialize(deserializer)?;
698        Ok(match s {
699            "" | "0" => ExactTimes::FrequencyBased,
700            "1" => ExactTimes::ScheduleBased,
701            &_ => {
702                return Err(serde::de::Error::custom(format!(
703                    "Invalid value `{s}`, expected 0 or 1"
704                )));
705            }
706        })
707    }
708}
709
710/// Defines how many transfers can be done with on [crate::FareAttribute]
711#[derive(Debug, Default, Copy, Clone, PartialEq, Eq, Hash)]
712pub enum Transfers {
713    /// Unlimited transfers are permitted
714    #[default]
715    Unlimited,
716    /// No transfers permitted on this fare
717    NoTransfer,
718    /// Riders may transfer once
719    UniqueTransfer,
720    ///Riders may transfer twice
721    TwoTransfers,
722    /// Other transfer values
723    Other(i16),
724}
725
726impl<'de> Deserialize<'de> for Transfers {
727    fn deserialize<D>(deserializer: D) -> Result<Transfers, D::Error>
728    where
729        D: Deserializer<'de>,
730    {
731        let i = Option::<i16>::deserialize(deserializer)?;
732        Ok(match i {
733            Some(0) => Transfers::NoTransfer,
734            Some(1) => Transfers::UniqueTransfer,
735            Some(2) => Transfers::TwoTransfers,
736            Some(a) => Transfers::Other(a),
737            None => Transfers::default(),
738        })
739    }
740}
741
742impl Serialize for Transfers {
743    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
744    where
745        S: Serializer,
746    {
747        match self {
748            Transfers::NoTransfer => serialize_i16_as_str(serializer, 0),
749            Transfers::UniqueTransfer => serialize_i16_as_str(serializer, 1),
750            Transfers::TwoTransfers => serialize_i16_as_str(serializer, 2),
751            Transfers::Other(a) => serialize_i16_as_str(serializer, *a),
752            Transfers::Unlimited => serializer.serialize_none(),
753        }
754    }
755}
756/// Defines the type of a [crate::StopTransfer]
757#[derive(Debug, Serialize, Default, Copy, Clone, PartialEq, Eq, Hash)]
758pub enum TransferType {
759    /// Recommended transfer point between routes
760    #[serde(rename = "0")]
761    #[default]
762    Recommended,
763    /// Departing vehicle waits for arriving one
764    #[serde(rename = "1")]
765    Timed,
766    /// Transfer requires a minimum amount of time between arrival and departure to ensure a connection.
767    #[serde(rename = "2")]
768    MinTime,
769    /// Transfer is not possible at this location
770    #[serde(rename = "3")]
771    Impossible,
772    /// Passengers can stay onboard the same vehicle to transfer from one trip to another
773    #[serde(rename = "4")]
774    StayOnBoard,
775    /// In-seat transfers aren't allowed between sequential trips.
776    /// The passenger must alight from the vehicle and re-board.
777    #[serde(rename = "5")]
778    MustAlight,
779}
780
781impl<'de> Deserialize<'de> for TransferType {
782    fn deserialize<D>(deserializer: D) -> Result<TransferType, D::Error>
783    where
784        D: Deserializer<'de>,
785    {
786        let s = <&str>::deserialize(deserializer)?;
787        Ok(match s {
788            "" | "0" => TransferType::Recommended,
789            "1" => TransferType::Timed,
790            "2" => TransferType::MinTime,
791            "3" => TransferType::Impossible,
792            "4" => TransferType::StayOnBoard,
793            "5" => TransferType::MustAlight,
794            s => {
795                return Err(serde::de::Error::custom(format!(
796                    "Invalid value `{s}`, expected 0, 1, 2, 3, 4, 5"
797                )));
798            }
799        })
800    }
801}
802
803/// Type of pathway between [crate::RawPathway::from_stop_id] and [crate::RawPathway::to_stop_id]
804#[derive(Debug, Serialize, Deserialize, Default, Copy, Clone, PartialEq, Eq, Hash)]
805pub enum PathwayMode {
806    /// A walkway
807    #[serde(rename = "1")]
808    #[default]
809    Walkway,
810    /// Stairs
811    #[serde(rename = "2")]
812    Stairs,
813    /// Moving sidewalk / travelator
814    #[serde(rename = "3")]
815    MovingSidewalk,
816    /// Escalator
817    #[serde(rename = "4")]
818    Escalator,
819    /// Elevator
820    #[serde(rename = "5")]
821    Elevator,
822    /// A pathway that crosses into an area of the station where a
823    /// proof of payment is required (usually via a physical payment gate)
824    #[serde(rename = "6")]
825    FareGate,
826    /// Indicates a pathway exiting an area where proof-of-payment is required
827    /// into an area where proof-of-payment is no longer required.
828    #[serde(rename = "7")]
829    ExitGate,
830}
831
832/// Indicates in which direction the pathway can be used
833#[derive(Debug, Serialize, Deserialize, Default, Copy, Clone, PartialEq, Eq, Hash)]
834pub enum PathwayDirectionType {
835    /// Unidirectional pathway, it can only be used from [crate::RawPathway::from_stop_id] to [crate::RawPathway::to_stop_id].
836    #[serde(rename = "0")]
837    #[default]
838    Unidirectional,
839    /// Bidirectional pathway, it can be used in the two directions.
840    #[serde(rename = "1")]
841    Bidirectional,
842}
843
844/// Defines the type of a [crate::FareMedia]
845#[derive(Debug, Deserialize, Serialize, Copy, Clone, PartialEq, Eq)]
846pub enum FareMediaType {
847    /// Used when there is no fare media involved in purchasing or validating a fare product
848    #[serde(rename = "0")]
849    None,
850    /// Physical paper ticket
851    #[serde(rename = "1")]
852    PhysicalPaperTicket,
853    /// Physical transit card
854    #[serde(rename = "2")]
855    PhysicalTransitCard,
856    /// cEMV (contactless Europay, Mastercard and Visa)
857    #[serde(rename = "3")]
858    CEmv,
859    /// Mobile app
860    #[serde(rename = "4")]
861    MobileApp,
862}
863
864/// Specifies if an entry in rider_categories.txt should be considered the default category
865#[derive(Debug, Serialize, Copy, Clone, PartialEq, Eq, Hash)]
866pub enum DefaultFareCategory {
867    /// Category is not considered the default.
868    NotDefault = 0,
869    /// Category is considered the default one.
870    Default = 1,
871}
872
873impl<'de> Deserialize<'de> for DefaultFareCategory {
874    fn deserialize<D>(deserializer: D) -> Result<DefaultFareCategory, D::Error>
875    where
876        D: Deserializer<'de>,
877    {
878        let s = <&str>::deserialize(deserializer)?;
879        Ok(match s {
880            "" | "0" => DefaultFareCategory::NotDefault,
881            "1" => DefaultFareCategory::Default,
882            &_ => {
883                return Err(serde::de::Error::custom(format!(
884                    "Invalid value `{s}`, expected 0 or 1"
885                )));
886            }
887        })
888    }
889}
890
891/// Specifies whether tickets can be bought for this item
892#[derive(Debug, Default, Deserialize, Serialize, Copy, Clone, PartialEq, Eq)]
893pub enum TicketingType {
894    /// If a ticketing_deep_link_id is set, tickets are available
895    #[default]
896    #[serde(rename = "0")]
897    Available,
898    /// Tickets are unavailable
899    #[serde(rename = "1")]
900    Unavailable,
901}
gtfs_structures/enums.rs

gtfs_structures/
enums.rs
