MultiCriteriaHybridDijkstra.h

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


#ifndef HYBRIDMULTICRITERIADIJKSTRA_H_
#define HYBRIDMULTICRITERIADIJKSTRA_H_

#include <vector>
#include "./TransitNetworkDependent.h"
#include "./TransitNetworkExpanded.h"
#include "./TransitPath.h"
#include "./Label.h"
#include "./LiveConnection.h"
#include "HybridTransitRoadNetwork.h"

using std::vector;



class MultiCriteriaHybridDijkstra {
public:
  MultiCriteriaHybridDijkstra(HybridTransitRoadNetwork* hybridNetwork);
  virtual ~MultiCriteriaHybridDijkstra();
  // convenience function, just calls the function below with
  // NetworkType = TransitNetwork
  double computeShortestPath(string startStop, Time time,
                             string endStop, bool buildPath);

  // computes shortest Path from startid to endid
  // startid is a node id in the road network
  // or a station id in the transit network
  // (be aware node id = station id in the dependent network
  // but not in the expanded network...)
  double computeShortestPath(int startId, NetworkType startNodeType,
                             const Time& startTime,
                             int endId, NetworkType endNodeType,
                             bool reconstructPath);
  string createDijkstraStatisticsJSON();
  string createDijkstraLocationsJSON(const unordered_set<int>&
                                          affectedLabelIds) const;
  //TODO(Robin): redo as const function?
  string createDijkstraStepJSON(int stepNumber, int expandedLabelId,
                          unordered_set<int>* labelIdsAffectedInThisStep);
  string createDijkstraStepsJSON(int startStep,int endStep);
  // For the hybrid Server
  void createAddedAndRemovedMaps();
  void printStatistic(int explored, int expanded, int pushed, int poped);
  vector<TransitPath> optimalPaths;
  string statistic;
private:
  void reconstructShortestPath(const Time& startTime,
                               NetworkType startType, size_t startId,
                               NetworkType endType, size_t endId);
  // redo this to also accept same parameters as function above and to truly work
  // in hybrid network
  void reconstructShortestPath( const Time& startTime, int startID);

  HybridTransitRoadNetwork* hybridNetwork;
  vector <Label> labels;
  vector <LabelSet> transitLabelSets;
  vector <LabelSet> roadLabelSets;
  vector<NetworkType> labelTypes;
  LabelSet endParitySet;
  unordered_map<int, vector<int> > _labelIdToRemovedLabelIds;
  unordered_map<int, vector<int> > _labelIdToAddedLabelIds;
};

#endif  // HYBRIDMULTICRITERIADIJKSTRA_H */