TransitNetworkExpanded.h

/* Copyright Robin Schirrmeister and Simon Skilevic
 * Lecture Efficient Route Planning summer semester 2011
 * Uni Freiburg
 * Class for a Graph of a Transit Network
 */

#ifndef ROUTEPLANNINGV2_TRANSITNETWORK_H_
#define ROUTEPLANNINGV2_TRANSITNETWORK_H_

#include <gtest/gtest.h>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <utility>
#include <vector>
#include "./RoadNetwork.h"
#include "./NodeExpanded.h"
#include "./TransitParser.h"
#include "./LiveConnection.h"

using std::string;
using std::unordered_set;
using std::unordered_map;
using std::pair;
using std::vector;

// A time-expanded transit network for one day (monday):
// Network of a public transportation system
// with nodes for every "event" at a station, i.e. for every
// time a vehicle departs from a station (departure-node),
// arrives at a station (arrivalnode)
// or there is a possibility for transferring lines after arrival (transfernode)
// this network parses the data from a GTFS File, but only uses the
// data for monday
class TransitNetworkExpanded : public Graph
{
 public:
  TransitNetworkExpanded();
  TransitNetworkExpanded(const TransitNetworkExpanded& orig);
  virtual ~TransitNetworkExpanded();
  FRIEND_TEST(TransitNetworkTest, parseFromGTFSFiles);
  FRIEND_TEST(TransitNetworkTest, computeShortestPathTransit);
  // construct the graph for the given weekday from gtfs files..
  void parseFromGTFSFiles(const string& folderName, char validWeekday,
                          int transferTimeInSeconds);
  // this function calculates the time of the edge by using
  // the times of the nodes plus the given difference in days,
  // then adds an edge inbetween the given ids
  void addEdgeWithTimeDifference(int startId, int endId);
  // add a node with a trip Id
  void addNodeOfTrip(NodeExpanded node, int tripId);
  // Add a new stop to the Network...
  void addStop(const Stop& newStop);
  size_t getNumStops();
  // get the nodes for a specific stop, return true on success
  // false if stop not found...
  bool getStopNodeIds(const string& stopName, vector<int>* stopNodeIds) const;
  // get stop node ids for a specific stop id
  const vector<int>& getStopNodeIds(int stopId);
  // get all stop names starting with given prefix
  void getStopsStartingWith(const string& prefix,
                            vector<string>* stopNames) const;
  // get name of stop with this id...
  string getStopName(int stopId);
  // get stop with this id...
  Stop* getStop(int stopId);
  // get id of stop with this name...
  int getStopId(const string& stopName);
  // get the trip id of this node...
  int getTripId(int nodeId);
  // get ids of nodes you should use when starting your trip
  // at the starttime at the given stop
  void getStartNodeIds(int stopId, const Time& startTime,
                       vector<int>* startNodeIds);
  int getVerbosity();
  void setVerbosity(int verbosity);
  void getConnections(int nodeId, bool isStartNode, Time arrivalTime,
                      vector<LiveConnection>* outConnections);



 private:
   // parse the calendar file, extract the service ids that
   // are available on the given weekday... ( (0 = monday to 6 = sunday)
  FRIEND_TEST(TransitNetworkTest, parseCalendarFile);
  void parseCalendarFile(const string& calendarFileName,
                         char validWeekDay,
                         unordered_set<string>* validServiceIds);

  FRIEND_TEST(TransitNetworkTest, parseTripsFile);
  void parseTripsFile(const string& tripFileName,
                     const unordered_set<string>& validServiceIds,
                     unordered_map<string, int>* tripIdNameToTripId);
 
  FRIEND_TEST(TransitNetworkTest, parseStopsFile);
  void parseStopsFile(const string& stopFileName,
                      vector<Stop>* stops,
                      unordered_map<string, int>* stopIdNameToId);

  // TODO(Robin): make it so that it does not parse a single frequency
  // for a trip id, but a vector of frequencies, and then adds trips for all
  // frequencies in the vector in parse stop times...
  FRIEND_TEST(TransitNetworkTest, parseFrequenciesFile);
  void parseFrequenciesFile(const string& frequencyFileName,
          unordered_map<string, vector<TransitParser::TripFrequency> >*
                           tripIdNameToFrequencies);
  FRIEND_TEST(TransitNetworkTest, parseStopTimesFile);
  void parseStopTimesFile(const string& stopTimesFile,
      const unordered_map<string, int>& stopIdNameToId,
      const unordered_map<string, vector<TransitParser::TripFrequency> >&
                                          tripIdNameToFrequencies,
      const unordered_map<string, int>& tripIdNameToTripId,
      int transferTimeInSeconds);

  FRIEND_TEST(TransitNetworkTest, addTrip);
  // add a certain trip to this network... the trip should be given
  // as arrival node transfer node departure node... always in this order..
  void addTrip(const vector<TransitParser::TripNode>& trip,
               const TransitParser::TripFrequency& frequency,
               vector<vector<int> >* stopIdToNodeIds,
               int tripId);
  void addTransferEdges(const vector<vector<int> >&
                        stopIdsToNodeIds);
  vector<Stop> _stops;
  // TODO(Robin): make into hashmap?
  // a vector mapping the nodes to their trip ids
  vector<int> _tripIds;
  // TODO(Robin): remember the tripId
  // vector<pair<string, string> >* tripIdToLineNameAndDirection;
  // the verbosity of the network, especially during parsing process...
  int _verbosity;
};
#endif  // ROUTEPLANNINGV2_TRANSITNETWORK_H_