TransitNetworkDependent.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_TRANSITNETWORKDEPENDENT_H_
#define ROUTEPLANNINGV2_TRANSITNETWORKDEPENDENT_H_

#include <gtest/gtest.h>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <utility>
#include <vector>
#include "./RoadNetwork.h"
#include "./NodeDependent.h"
#include "./EdgeDependent.h"
#include "./Time.h"
#include "./TransitParser.h"
#include "./LiveConnection.h"
using std::string;
using std::unordered_map;
using std::unordered_set;
using std::pair;
using std::vector;
// TODO(Robin): make stop struct for stops
class TransitNetworkDependent : public Graph
{
  // frequency of a trip, the start and endtime of the trip
  // and the interval in minutes inbetween start times..
  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);
  };

 public:
  TransitNetworkDependent();
  TransitNetworkDependent(const TransitNetworkDependent& orig);
  virtual ~TransitNetworkDependent();
  FRIEND_TEST(TransitNetworkTest, parseFromGTFSFiles);
  FRIEND_TEST(TransitNetworkTest, computeShortestPathTransit);
  // construct the graph from gtfs files..
  void parseFromGTFSFiles(string folderName);
  // this function calculates the time of the edge by using
  // the weekdates of the nodes
  void addEdgeWithTimeDifference(int startId, int endId);
  // get Node/Stop name by Id
  string getStopName(size_t id);
  // get nummber of existing Nodes
  size_t getNumNodes() const;
  // returns same as get num nodes...
  size_t getNumStops() const;
  // get Node-object by id
  NodeDependent* getNode(int id) const;
  // get outgoing edges of Node given by its Id
  vector<EdgeDependent>* getOutEdges(int nodeId) const;
  // get all StopName beginnig with the given prefix
  void getStopsStartingWith(const string& prefix,
                            vector<string>* stopNames) const;
  // return StopId coresponded to given StopName
  int getNodeIdByTheStopName(string stopName);

  void getConnections(int nodeId, Time time, int tripId,
  bool isMultiCriteria, bool isStartNode,
                              vector<LiveConnection>* outConnections);
  
 private:
  FRIEND_TEST(TransitNetworkTest, parseCalendarFile);
  void parseCalendarFile(const string& calendarFileName,
                         char validWeekDay,
                         unordered_set<string>* validServiceIds);

  FRIEND_TEST(TransitNetworkTest, parseTripsFile);
  void parseTripsFile(string tripFileName,
                     const unordered_set<string>& validServiceIds,
                     unordered_map<string, int>* tripIdNameToTripId);

  FRIEND_TEST(TransitNetworkDependentTest, parseStopsFile);
  void parseStopsFile(string stopFileName);

  //FRIEND_TEST(TransitNetworkTest, parseFrequenciesFile);
  void parseFrequenciesFile(string frequencyFileName,
            unordered_map<string, vector<TransitParser::TripFrequency> >*
             tripIdNameToFrequencies);
  //FRIEND_TEST(TransitNetworkTest, parseStopTimesFile);
  void parseStopTimesFile(string stopTimesFile,
        const unordered_map<string, vector<TransitParser::TripFrequency> >&
                                          tripIdNameToFrequencies,
        const unordered_map<string, int >& tripStrToIntId);

  FRIEND_TEST(TransitNetworkTest, addTrip);
  // add a certain trip to this network...
  // as trip is meant a connection between two naighboring nodes
  void addTrip(int startNodeId, int endNodeId,
               const TransitParser::TripFrequency& frequency,
               Time startTime, Time endTime,
               int tripId);
  // add Adge to the network
  void addEdge(int startId, int endId);
  // add stop-time to to the coresponded Edge
  void addStopTimeToCorrespondEdge(int startStopId, int endStopId,
                                   Time startTime,
                                   Time endTime,
                                   int lineId);
  vector<NodeDependent>* _nodes;
  vector<vector<EdgeDependent> >* _outgoingEdges;
  vector<vector<EdgeDependent> >* _incomingEdges;
  vector<vector<bool> > availableWeekdays;
  unordered_map<string, int>* _stopIdNameToId;
  vector <string> _stopIdToName;
};
#endif  // ROUTEPLANNINGV2_TRANSITNETWORKDEPENDENT_H_