TransitPath.h

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

#ifndef ROUTEPLANNING_TRANSITPATH_H_
#define ROUTEPLANNING_TRANSITPATH_H_
#include <vector>
#include <utility>
#include "./Time.h"

using std::vector;
using std::pair;
// a Path in a transit network...
class TransitPath
{
 public:
  enum PathNodeType
  {
    TRANSITNODE, ROADNODE
  };
  TransitPath(const Time& startTime);
  // clear the path
  void clear();
  // reverse the path
  void reverse();
  // return amount of nodes in the path
  size_t size() const;
  const Time& getStartTime() const;
  // get the amount of transfers on that trip
  int getTransfers() const;
  // get the duration of that trip!
  double getDurationInMinutes() const;
  // add a new station with id arrival and departure times to the path
  void addStation(PathNodeType type, int stationId,
                  double latitude, double longitude,
                  Time arrivalTime, Time departureTime,
                  int arrivedWithTripId);
  PathNodeType getType(int pathNodeIndex);
  int getStationId(int pathNodeIndex);
  double getLatitude(int pathNodeIndex);
  double getLongitude(int pathNodeIndex);
  const Time& getArrivalTime(int pathNodeIndex);
  const Time& getDepartureTime(int pathNodeIndex);
  int getArrivedWithTripId(int pathNodeIndex);
  // return if transit paths are equal or not...
  bool isEqualTo (const TransitPath& otherPath) const;
  // return if transit paths have same duration and same transfers...
  bool hasSameResult (const TransitPath& otherPath) const;
  // show a diff to the other path
  string createDiffTo(const TransitPath& otherPath) const;
  string toString() const;
  // creates a JSON string from this path...
  string createJSON() const;
  // Compare two vectors with transit paths, find out which
  // transit paths have no equal path in the other vector
  // This function will not recognize if there is a duplicate path in the
  // first vector ( it will return duplicates from the second though)
  // This function returns the indices of those paths
  // in the vectors that do not have an equal paths in the other vector...
  static pair<vector<int>, vector<int> > findDifferentPaths(
                                       const vector<TransitPath>& firstPaths,
                                       const vector<TransitPath>& secondPaths);
  // same as function above but only returns those paths
  // that have different durations or transfers
  static pair<vector<int>, vector<int> > findDifferentResults(
                                       const vector<TransitPath>& firstPaths,
                                       const vector<TransitPath>& secondPaths);

 private:
  // show a diff to the other path
  string createDiffOrString(const TransitPath& otherPath,
                            bool createDiff) const;
  // the starting time of the query this path was constructed for
  Time _startTime;

  // struct for the nodes on the path 
  struct PathNode
  {
    PathNodeType type;
    int stationId;
    double latitude;
    double longitude;
    Time arrivalTime;
    Time departureTime;
    int arrivedWithTripId;
    PathNode(PathNodeType type, int stationId,
             double latitude, double longitude,
             Time arrivalTime, Time departureTime,
             int arrivedWithTripId);
    // return if path node is equal to other path node or not
    bool isEqualTo (const PathNode& otherPathNode) const;
    string createJSON() const;
  };
  // the path itself
  vector<PathNode> _pathNodes;
};

#endif  // ROUTEPLANNING_TRANSITPATH_H_