TransitParser.h

// Copyright November 18, 2011 Robin Schirrmeister and Simon Skilevic
// Chair of Algorithms and Datastructures Uni Freiburg

#ifndef ROUTEPLANNING_TRANSITPARSER_H_
#define ROUTEPLANNING_TRANSITPARSER_H_
#include <string>
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include "./NodeExpanded.h"
#include "./CsvParser.h"
using std::string;
using std::vector;
using std::unordered_set;
using std::unordered_map;

// Parser Helper class for the Transit Networks, to be used by both
// TransitNetworkExpanded as well as TransitNetworkDependent
// verbosity specififes hwo much of the parsing is logged to the console
// (0 = nothing, 1 = only errors, 2 = errors and progress)

// a stop, with name, latitude, longitude, and corresponding nodes...
struct Stop
{
  int stopId;
  string stopName;
  double latitude;
  double longitude;
  vector<int> nodeIdsSortedByTime;
  Stop(int stopId, const string& stopName, double latitude, double longitude);
};
class TransitParser {
public:

  // a node of a trip, its time can go beyond 24 hours (for
  // differentiating between this day and next day)
  struct TripNode
  {
    // construct the time out of a string like "25:30:00"
    // for 1:30 am the next day
    // or 16:30:45 for 16:30 and 45 seconds on this day..
    TripNode(const string& GTFSTimeString, int stopId, NodeType type);
    int stopId;
    int secondsSinceDay;
    NodeType type;
  };  // Frequency of a Trip:
  // the start and endtime of the trip
  // and the interval in minutes inbetween the start times of the trip..
  // this is just a struct helpful for the parsing process
  struct TripFrequency
  {
    char startHour;
    char startMinute;
    char startSecond;
    char endHour;
    char endMinute;
    char endSecond;
    int intervalInSeconds;
    TripFrequency();
    TripFrequency(char startHour, char startMinute, char startSecond,
                  char endHour, char endMinute, char endSecond,
                  int intervalInSeconds);
  };
  struct Trip
  {
    int tripId;
    vector <TripNode> nodes;
    vector<TripFrequency> frequencies;
  };

  TransitParser(int verbosity);
  void parseCalendarFile(const string& calendarFileName,
                                       char validWeekDay,
                                       unordered_set<string>* validServiceIds);
  void parseTripsFile(const string& tripFileName,
                      const unordered_set<string>& validServiceIds,
                      unordered_map<string, int>* tripIdNameToTripId);
  void parseStopsFile(const string& stopFileName,
                      vector<Stop>* stops,
                      unordered_map<string, int>* stopIdNameToId);
  void parseFrequenciesFile(const string& frequencyFileName,
                          unordered_map<string,
                          vector<TripFrequency> >*
                          tripIdNameToFrequencies);
  void parseStopTimesFile(const string& stopTimesFile,
        const unordered_map<string, int>& stopIdNameToId,
        const unordered_map<string, vector<TripFrequency> >&
                                          tripIdNameToFrequencies,
        const unordered_map<string, int>& tripIdNameToTripId,
        int transferTimeInSeconds,
        vector<Trip>* parsedTrips);

private:
  int _verbosity;

};

#endif  // ROUTEPLANNING_TRANSITPARSER_H_