HybridTransitRoadNetwork.h

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


#ifndef HYBRIDTRANSITROADNETWORK_H_
#define HYBRIDTRANSITROADNETWORK_H_

#include "RoadNetwork.h"
#include "./TransitNetworkDependent.h"
#include "./TransitNetworkExpanded.h"
#include "./Time.h"
#include "./LiveConnection.h"
#include "ExpandedDijkstra.h"


using std::vector;


class HybridTransitRoadNetwork {
public:
  HybridTransitRoadNetwork(RoadNetwork* roadNetwork,
                           TransitNetworkDependent* transitNetworkDependent,
                           TransitNetworkExpanded* transitNetworkExpanded);
  virtual ~HybridTransitRoadNetwork();
  void getStopsStartingWith(const string& prefix,
                                          vector<string>* stopNames);
  void getStartConnections(int startId, NetworkType startNodeType,
                                   const Time& startTime,
                                   vector<LiveConnection>* startConnections);
  void addNaighbourConnections(int nodeId, NetworkType type,
                               int endId,
                               NetworkType endType,
                               bool startStation,
                               Time arrivalTime,
                               vector<LiveConnection>* outConnections);
  int getStopIdByTheStopName(string stopName);
  bool isExpanded();
  int getNumNodes(NetworkType type);
  int getNumStops(NetworkType type);
  void addDummyNode(int startId, const Time& startTime);
  void removeDummyNode();
  // returns either the stop id from expanded network or the node id
  // from road or dependent network
  int getLocationId(NetworkType type, int nodeId);
  NodeExpanded* getNode(NetworkType type, int nodeId);

  int getTripId(NetworkType netType, int nodeId);
  void buildHybridNetwork(int naighboursNumber);
  void getConnections(int nodeId, NetworkType type,
                      int endId, NetworkType endType, Time arrivalTime,
                      int tripId, bool isMultiCriteria, bool isStartNode,
                      vector<LiveConnection>* outConnections);
  bool equalWithStartStation(NetworkType nodeType, int startId,
                              NetworkType otherNodeType,
                              int otherNodeId);
  bool equalWithEndStation(NetworkType nodeType, int endId,
                            NetworkType otherNodeType,
                            int otherNodeId);
  double getLatitude(NetworkType type, int nodeId);
  double getLongitude(NetworkType type, int nodeId);

private:
  RoadNetwork* _roadNetwork;
  TransitNetworkExpanded* _transitNetworkExpanded;
  TransitNetworkDependent* _transitNetworkDependent;
  vector <vector <Edge> > _transitIdToRoadIds;
  vector <vector <Edge> > _roadIdToTransitIds;
};

#endif  /* HYBRIDTRANSITROADNETWORK_H */