clean up and refactor half-baked development commits and squash them into a new version.

Changes:

* support for multiple GTFS feeds as input in filtering, read default global and local configuration files
* be a bit more memory conservative
* make caching optional
* dont delete orphan edge if it would transform a degree 3 node with a possible full turn into a degree 2 node eligible for contraction
* dedicated filters for funicular and gondola
* make max snap level option more intuitive
* allow filter rules for level 0
* additional fallback for station snapping
* dont try to route for MOT unequal to trip in -T mode, force-snap to orphaned OSM station if not snap was possible
* write bounds to filtered osm
* remove unused surrounding heuristic
* use bus lanes info
* be a bit more tolerant for bus oneway streets
* create missing directories
* error if no cfg is present, clean up evaluation Makefile

src/pfaedle/gtfs/Feed.h

@@ -0,0 +1,37 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef PFAEDLE_GTFS_FEED_H_
+#define PFAEDLE_GTFS_FEED_H_
+
+#include <string>
+#include "Route.h"
+#include "Service.h"
+#include "ShapeContainer.h"
+#include "StopTime.h"
+#include "ad/cppgtfs/gtfs/ContContainer.h"
+#include "ad/cppgtfs/gtfs/Feed.h"
+#include "ad/cppgtfs/gtfs/NullContainer.h"
+#include "ad/cppgtfs/gtfs/Stop.h"
+#include "ad/cppgtfs/gtfs/StopTime.h"
+#include "ad/cppgtfs/gtfs/Trip.h"
+
+namespace pfaedle {
+namespace gtfs {
+
+typedef ad::cppgtfs::gtfs::FeedB<
+    ad::cppgtfs::gtfs::Agency, Route, ad::cppgtfs::gtfs::Stop, Service,
+    StopTime, Shape, ad::cppgtfs::gtfs::Fare, ad::cppgtfs::gtfs::Container,
+    ad::cppgtfs::gtfs::ContContainer, ad::cppgtfs::gtfs::NullContainer,
+    ad::cppgtfs::gtfs::ContContainer, ad::cppgtfs::gtfs::ContContainer,
+    ShapeContainer, ad::cppgtfs::gtfs::NullContainer>
+    Feed;
+typedef ad::cppgtfs::gtfs::TripB<StopTime<ad::cppgtfs::gtfs::Stop>, Service,
+                                 Route, Shape>
+    Trip;
+
+}  // namespace gtfs
+}  // namespace pfaedle
+
+#endif  // PFAEDLE_GTFS_FEED_H_

src/pfaedle/gtfs/Route.h

@@ -0,0 +1,61 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef PFAEDLE_GTFS_ROUTE_H_
+#define PFAEDLE_GTFS_ROUTE_H_
+
+#include <stdint.h>
+#include <algorithm>
+#include <iomanip>
+#include <set>
+#include <sstream>
+#include <string>
+#include "ad/cppgtfs/gtfs/Agency.h"
+#include "ad/cppgtfs/gtfs/Route.h"
+#include "util/Misc.h"
+
+using std::exception;
+using std::string;
+
+namespace pfaedle {
+namespace gtfs {
+
+class Route {
+ public:
+  typedef Route* Ref;
+  static std::string getId(Ref r) { return r->getId(); }
+
+  Route() {}
+
+  Route(const string& id, ad::cppgtfs::gtfs::Agency* agency,
+        const string& short_name, const string& long_name, const string& desc,
+        ad::cppgtfs::gtfs::flat::Route::TYPE type, const string& url,
+        uint32_t color, uint32_t text_color)
+      : _id(id), _short_name(short_name), _long_name(long_name), _type(type) {
+    UNUSED(agency);
+    UNUSED(desc);
+    UNUSED(url);
+    UNUSED(color);
+    UNUSED(text_color);
+  }
+
+  const std::string& getId() const { return _id; }
+
+  const std::string& getShortName() const { return _short_name; }
+
+  const std::string& getLongName() const { return _long_name; }
+
+  ad::cppgtfs::gtfs::flat::Route::TYPE getType() const { return _type; }
+
+ private:
+  string _id;
+  string _short_name;
+  string _long_name;
+  ad::cppgtfs::gtfs::flat::Route::TYPE _type;
+};
+
+}  // namespace gtfs
+}  // namespace pfaedle
+
+#endif  // PFAEDLE_GTFS_ROUTE_H_

src/pfaedle/gtfs/Service.h

@@ -0,0 +1,43 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef PFAEDLE_GTFS_SERVICE_H_
+#define PFAEDLE_GTFS_SERVICE_H_
+
+#include <string>
+#include "ad/cppgtfs/gtfs/Service.h"
+#include "util/Misc.h"
+
+namespace pfaedle {
+namespace gtfs {
+
+class Service {
+ public:
+  typedef std::string Ref;
+  static std::string getId(Ref r) { return r; }
+
+  explicit Service(const string& id) : _id(id) {}
+  Service(const string& id, uint8_t serviceDays,
+          ad::cppgtfs::gtfs::ServiceDate start,
+          ad::cppgtfs::gtfs::ServiceDate end)
+      : _id(id) {
+    UNUSED(serviceDays);
+    UNUSED(start);
+    UNUSED(end);
+  }
+
+  const std::string& getId() const { return _id; }
+  void addException(const ad::cppgtfs::gtfs::ServiceDate& d,
+                    ad::cppgtfs::gtfs::Service::EXCEPTION_TYPE t) {
+    UNUSED(d);
+    UNUSED(t);
+  }
+
+ private:
+  std::string _id;
+};
+}  // namespace gtfs
+}  // namespace pfaedle
+
+#endif  // PFAEDLE_GTFS_SERVICE_H_

src/pfaedle/gtfs/ShapeContainer.h

@@ -0,0 +1,69 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef PFAEDLE_GTFS_SHAPECONTAINER_H_
+#define PFAEDLE_GTFS_SHAPECONTAINER_H_
+
+#include <fstream>
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <string>
+#include "ad/cppgtfs/gtfs/Shape.h"
+#include "ad/cppgtfs/gtfs/flat/Shape.h"
+#include "util/Misc.h"
+
+namespace pfaedle {
+namespace gtfs {
+
+struct Shape {
+  explicit Shape(const std::string& id) : id(id) {}
+  typedef std::string Ref;
+  static std::string getId(Ref r) { return r; }
+
+  template <typename T>
+  bool addPoint(T p) {
+    UNUSED(p);
+    return true;
+  }
+
+  const std::string& getId() const { return id; }
+
+  std::string id;
+};
+
+template <typename T>
+class ShapeContainer {
+ public:
+  ShapeContainer();
+  ~ShapeContainer();
+  T* add(const T& obj);
+  bool remove(const std::string& id);
+  const T* get(const std::string& id) const;
+  T* get(const std::string& id);
+  const std::string getRef(const std::string& id) const;
+  std::string getRef(const std::string& id);
+  size_t size() const;
+  void finalize() {}
+  bool has(const std::string& id) const;
+
+  std::string add(const ad::cppgtfs::gtfs::Shape& s);
+  void open();
+  bool nextStoragePt(ad::cppgtfs::gtfs::flat::ShapePoint* ret);
+
+ private:
+  std::set<std::string> _ids;
+  std::fstream _storage;
+  size_t _ptr;
+  size_t _max;
+  std::string _curId;
+  std::stringstream _writeBuffer;
+};
+
+#include "ShapeContainer.tpp"
+
+}  // namespace gtfs
+}  // namespace pfaedle
+
+#endif  // PFAEDLE_GTFS_SHAPECONTAINER_H_

src/pfaedle/gtfs/ShapeContainer.tpp

@@ -0,0 +1,154 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <unistd.h>
+#include <string>
+
+// ____________________________________________________________________________
+template <typename T>
+ShapeContainer<T>::ShapeContainer() {
+  std::string f = ".pfaedle-tmp";
+
+  while (access(f.c_str(), F_OK) != -1) {
+    std::stringstream ss;
+    ss << ".pfaedle-tmp-";
+    ss << std::rand();
+    f = ss.str().c_str();
+  }
+
+  _storage.open(f, std::fstream::in | std::fstream::out | std::fstream::trunc);
+
+  // immediately unlink
+  unlink(f.c_str());
+
+  if (!_storage.good()) {
+    std::cerr << "Could not open temporary file " << f << std::endl;
+    exit(1);
+  }
+}
+
+// ____________________________________________________________________________
+template <typename T>
+ShapeContainer<T>::~ShapeContainer() {
+  _storage.close();
+}
+
+// ____________________________________________________________________________
+template <typename T>
+T* ShapeContainer<T>::add(const T& ent) {
+  _ids.insert(ent.getId());
+  return reinterpret_cast<T*>(1);
+}
+
+// ____________________________________________________________________________
+template <typename T>
+bool ShapeContainer<T>::remove(const std::string& id) {
+  _ids.erase(id);
+  return true;
+}
+
+// ____________________________________________________________________________
+template <typename T>
+T* ShapeContainer<T>::get(const std::string& id) {
+  if (!has(id)) return 0;
+  return reinterpret_cast<T*>(1);
+}
+
+// ____________________________________________________________________________
+template <typename T>
+const T* ShapeContainer<T>::get(const std::string& id) const {
+  if (!has(id)) return 0;
+  return reinterpret_cast<T*>(1);
+}
+
+// ____________________________________________________________________________
+template <typename T>
+bool ShapeContainer<T>::has(const std::string& id) const {
+  return _ids.count(id);
+}
+
+// ____________________________________________________________________________
+template <typename T>
+size_t ShapeContainer<T>::size() const {
+  return _ids.size();
+}
+
+// ____________________________________________________________________________
+template <typename T>
+std::string ShapeContainer<T>::add(const ad::cppgtfs::gtfs::Shape& s) {
+  if (has(s.getId())) return s.getId();
+  _ids.insert(s.getId());
+
+  _writeBuffer << s.getId() << '\t' << s.getPoints().size();
+  _writeBuffer << std::setprecision(11);
+  for (auto p : s.getPoints()) {
+    _writeBuffer << " " << p.lat << " " << p.lng << " " << p.travelDist;
+  }
+  // entries are newline separated
+  _writeBuffer << '\n';
+
+  if (_writeBuffer.tellp() > 1000 * 5000) {
+    _storage << _writeBuffer.rdbuf();
+    _writeBuffer.clear();
+  }
+
+  return s.getId();
+}
+
+// ____________________________________________________________________________
+template <typename T>
+void ShapeContainer<T>::open() {
+  _storage << _writeBuffer.rdbuf();
+  _writeBuffer.clear();
+
+  _ptr = 0;
+  _max = 0;
+  _storage.clear();
+  _storage.seekg(0, std::ios::beg);
+}
+
+// ____________________________________________________________________________
+template <typename T>
+bool ShapeContainer<T>::nextStoragePt(
+    ad::cppgtfs::gtfs::flat::ShapePoint* ret) {
+  while (_storage.good() && !_storage.fail()) {
+    if (!_ptr) {
+      _storage >> _curId;
+      _storage >> _max;
+    }
+
+    if (!_storage.good() || _storage.fail()) return false;
+
+    _storage >> ret->lat;
+    _storage >> ret->lng;
+    _storage >> ret->travelDist;
+    ret->seq = _ptr + 1;
+    ret->id = _curId;
+
+    if (_ptr + 1 == _max)
+      _ptr = 0;
+    else
+      _ptr++;
+
+    if (!_storage.good() || _storage.fail()) return false;
+
+    if (has(ret->id)) return true;
+  }
+
+  return false;
+}
+
+// ____________________________________________________________________________
+template <typename T>
+const std::string ShapeContainer<T>::getRef(const std::string& id) const {
+  if (!has(id)) return "";
+  return id;
+}
+
+// ____________________________________________________________________________
+template <typename T>
+std::string ShapeContainer<T>::getRef(const std::string& id) {
+  if (!has(id)) return "";
+  return id;
+}

src/pfaedle/gtfs/StopTime.h

@@ -0,0 +1,71 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef PFAEDLE_GTFS_STOPTIME_H_
+#define PFAEDLE_GTFS_STOPTIME_H_
+
+#include <iomanip>
+#include <sstream>
+#include <string>
+#include <vector>
+#include "ad/cppgtfs/gtfs/Stop.h"
+#include "ad/cppgtfs/gtfs/StopTime.h"
+#include "util/Misc.h"
+
+using std::exception;
+using std::string;
+
+namespace pfaedle {
+namespace gtfs {
+
+template <typename StopT>
+class StopTime {
+ public:
+  StopTime(const ad::cppgtfs::gtfs::Time& at, const ad::cppgtfs::gtfs::Time& dt,
+           typename StopT::Ref s, uint32_t seq, const std::string& hs,
+           ad::cppgtfs::gtfs::flat::StopTime::PU_DO_TYPE put,
+           ad::cppgtfs::gtfs::flat::StopTime::PU_DO_TYPE dot, float distTrav,
+           bool isTp)
+      : _s(s), _sequence(seq), _dist(distTrav) {
+    UNUSED(at);
+    UNUSED(dt);
+    UNUSED(hs);
+    UNUSED(put);
+    UNUSED(dot);
+    UNUSED(distTrav);
+    UNUSED(isTp);
+  }
+
+  const typename StopT::Ref getStop() const { return _s; }
+  typename StopT::Ref getStop() { return _s; }
+  void setShapeDistanceTravelled(double d) { _dist = d; }
+
+  ad::cppgtfs::gtfs::Time getArrivalTime() const {
+    return ad::cppgtfs::gtfs::Time(0, 0, 0);
+  }
+  ad::cppgtfs::gtfs::Time getDepartureTime() const {
+    return ad::cppgtfs::gtfs::Time(0, 0, 0);
+  }
+
+  float getShapeDistanceTravelled() const { return _dist; }
+
+  uint16_t getSeq() const { return _sequence; }
+
+ private:
+  typename StopT::Ref _s;
+  uint32_t _sequence;
+  float _dist;
+};
+
+template <typename StopTimeT>
+struct StopTimeCompare {
+  bool operator()(const StopTimeT& lh, const StopTimeT& rh) const {
+    return lh.getSeq() < rh.getSeq();
+  }
+};
+
+}  // namespace gtfs
+}  // namespace pfaedle
+
+#endif  // PFAEDLE_GTFS_STOPTIME_H_

src/pfaedle/gtfs/Writer.cpp

@@ -0,0 +1,495 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <cstdio>
+#include <fstream>
+#include <map>
+#include <string>
+#include <utility>
+#include "ad/cppgtfs/Parser.h"
+#include "ad/cppgtfs/Writer.h"
+#include "ad/cppgtfs/gtfs/flat/Agency.h"
+#include "ad/util/CsvWriter.h"
+#include "pfaedle/gtfs/Writer.h"
+
+using ad::util::CsvWriter;
+using ad::cppgtfs::Parser;
+using pfaedle::gtfs::Writer;
+
+// ____________________________________________________________________________
+bool Writer::write(gtfs::Feed* sourceFeed, const std::string& path) const {
+  std::ofstream fs;
+  std::ifstream is;
+  std::string gtfsPath(path);
+  std::string curFile;
+  std::string curFileTg;
+
+  curFile = gtfsPath + "/.agency.txt";
+  curFileTg = gtfsPath + "/agency.txt";
+  fs.open(curFile.c_str());
+  if (!fs.good()) cannotWrite(curFile, curFileTg);
+  writeAgency(sourceFeed, &fs);
+  fs.close();
+  std::rename(curFile.c_str(), curFileTg.c_str());
+
+  curFile = gtfsPath + "/.stops.txt";
+  curFileTg = gtfsPath + "/stops.txt";
+  fs.open(curFile.c_str());
+  if (!fs.good()) cannotWrite(curFile, curFileTg);
+  writeStops(sourceFeed, &fs);
+  fs.close();
+  std::rename(curFile.c_str(), curFileTg.c_str());
+
+  curFile = gtfsPath + "/.routes.txt";
+  curFileTg = gtfsPath + "/routes.txt";
+  fs.open(curFile.c_str());
+  if (!fs.good()) cannotWrite(curFile, curFileTg);
+  writeRoutes(sourceFeed, &fs);
+  fs.close();
+  std::rename(curFile.c_str(), curFileTg.c_str());
+
+  is.open((sourceFeed->getPath() + "/calendar.txt").c_str());
+  if (is.good()) {
+    is.close();
+    curFile = gtfsPath + "/.calendar.txt";
+    curFileTg = gtfsPath + "/calendar.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeCalendar(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  is.open((sourceFeed->getPath() + "/calendar_dates.txt").c_str());
+  if (is.good()) {
+    is.close();
+    curFile = gtfsPath + "/.calendar_dates.txt";
+    curFileTg = gtfsPath + "/calendar_dates.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeCalendarDates(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  is.open((sourceFeed->getPath() + "/transfers.txt").c_str());
+  if (is.good()) {
+    is.close();
+    curFile = gtfsPath + "/.transfers.txt";
+    curFileTg = gtfsPath + "/transfers.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeTransfers(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  is.open((sourceFeed->getPath() + "/fare_attributes.txt").c_str());
+  if (is.good()) {
+    is.close();
+    curFile = gtfsPath + "/.fare_attributes.txt";
+    curFileTg = gtfsPath + "/fare_attributes.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeFares(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  is.open((sourceFeed->getPath() + "/fare_rules.txt").c_str());
+  if (is.good()) {
+    is.close();
+    curFile = gtfsPath + "/.fare_rules.txt";
+    curFileTg = gtfsPath + "/fare_rules.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeFareRules(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  is.close();
+  curFile = gtfsPath + "/.shapes.txt";
+  curFileTg = gtfsPath + "/shapes.txt";
+  fs.open(curFile.c_str());
+  if (!fs.good()) cannotWrite(curFile, curFileTg);
+  writeShapes(sourceFeed, &fs);
+  fs.close();
+  std::rename(curFile.c_str(), curFileTg.c_str());
+
+  is.close();
+  curFile = gtfsPath + "/.trips.txt";
+  curFileTg = gtfsPath + "/trips.txt";
+  fs.open(curFile.c_str());
+  if (!fs.good()) cannotWrite(curFile, curFileTg);
+  bool hasFreqs = writeTrips(sourceFeed, &fs);
+  fs.close();
+  std::rename(curFile.c_str(), curFileTg.c_str());
+
+  is.open((sourceFeed->getPath() + "/frequencies.txt").c_str());
+  if (hasFreqs && is.good()) {
+    is.close();
+    curFile = gtfsPath + "/.frequencies.txt";
+    curFileTg = gtfsPath + "/frequencies.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeFrequencies(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  is.close();
+  curFile = gtfsPath + "/.stop_times.txt";
+  curFileTg = gtfsPath + "/stop_times.txt";
+  fs.open(curFile.c_str());
+  if (!fs.good()) cannotWrite(curFile, curFileTg);
+  writeStopTimes(sourceFeed, &fs);
+  fs.close();
+  std::rename(curFile.c_str(), curFileTg.c_str());
+
+  if (!sourceFeed->getPublisherUrl().empty() &&
+      !sourceFeed->getPublisherName().empty()) {
+    curFile = gtfsPath + "/.feed_info.txt";
+    curFileTg = gtfsPath + "/feed_info.txt";
+    fs.open(curFile.c_str());
+    if (!fs.good()) cannotWrite(curFile, curFileTg);
+    writeFeedInfo(sourceFeed, &fs);
+    fs.close();
+    std::rename(curFile.c_str(), curFileTg.c_str());
+  }
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeFeedInfo(gtfs::Feed* f, std::ostream* os) const {
+  auto csvw = ad::cppgtfs::Writer::getFeedInfoCsvw(os);
+  csvw.flushLine();
+  csvw.writeString(f->getPublisherName());
+  csvw.writeString(f->getPublisherUrl());
+  csvw.writeString(f->getLang());
+  if (!f->getStartDate().empty())
+    csvw.writeInt(f->getStartDate().getYYYYMMDD());
+  else
+    csvw.skip();
+  if (!f->getEndDate().empty())
+    csvw.writeInt(f->getEndDate().getYYYYMMDD());
+  else
+    csvw.skip();
+  csvw.writeString(f->getVersion());
+  csvw.flushLine();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeAgency(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/agency.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getAgencyCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Agency fa;
+  auto flds = Parser::getAgencyFlds(&csvp);
+
+  while (p.nextAgency(&csvp, &fa, flds)) {
+    w.writeAgency(fa, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeStops(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/stops.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getStopsCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Stop s;
+  auto flds = Parser::getStopFlds(&csvp);
+
+  while (p.nextStop(&csvp, &s, flds)) {
+    w.writeStop(s, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeRoutes(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/routes.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getRoutesCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Route s;
+  auto flds = Parser::getRouteFlds(&csvp);
+
+  while (p.nextRoute(&csvp, &s, flds)) {
+    w.writeRoute(s, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeCalendar(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/calendar.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getCalendarCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Calendar c;
+  auto flds = Parser::getCalendarFlds(&csvp);
+
+  while (p.nextCalendar(&csvp, &c, flds)) {
+    w.writeCalendar(c, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeCalendarDates(gtfs::Feed* sourceFeed,
+                                std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/calendar_dates.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getCalendarDatesCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::CalendarDate c;
+  auto flds = Parser::getCalendarDateFlds(&csvp);
+
+  while (p.nextCalendarDate(&csvp, &c, flds)) {
+    w.writeCalendarDate(c, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeFrequencies(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/frequencies.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getFrequencyCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Frequency f;
+  auto flds = Parser::getFrequencyFlds(&csvp);
+
+  while (p.nextFrequency(&csvp, &f, flds)) {
+    w.writeFrequency(f, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeTransfers(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/transfers.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getTransfersCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Transfer t;
+  auto flds = Parser::getTransfersFlds(&csvp);
+
+  while (p.nextTransfer(&csvp, &t, flds)) {
+    w.writeTransfer(t, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeFares(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/fare_attributes.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getFaresCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::Fare f;
+  auto flds = Parser::getFareFlds(&csvp);
+
+  while (p.nextFare(&csvp, &f, flds)) {
+    w.writeFare(f, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeFareRules(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/fare_rules.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getFareRulesCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::FareRule f;
+  auto flds = Parser::getFareRuleFlds(&csvp);
+
+  while (p.nextFareRule(&csvp, &f, flds)) {
+    w.writeFareRule(f, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeShapes(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/shapes.txt").c_str());
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getShapesCsvw(os);
+  csvw.flushLine();
+  ad::cppgtfs::gtfs::flat::ShapePoint sp;
+  ad::cppgtfs::Writer w;
+
+  if (fs.good()) {
+    CsvParser csvp(&fs);
+    Parser p;
+
+    auto flds = Parser::getShapeFlds(&csvp);
+
+    std::string curShapeId;
+    std::string curSkipShapeId;
+
+    while (p.nextShapePoint(&csvp, &sp, flds)) {
+      if (sp.id == curSkipShapeId) continue;
+      if (sp.id != curShapeId) {
+        if (sourceFeed->getShapes().has(sp.id)) {
+          curShapeId = sp.id;
+        } else {
+          curSkipShapeId = sp.id;
+          continue;
+        }
+      }
+
+      w.writeShapePoint(sp, &csvw);
+    }
+  }
+
+  sourceFeed->getShapes().open();
+  while (sourceFeed->getShapes().nextStoragePt(&sp)) {
+    w.writeShapePoint(sp, &csvw);
+  }
+
+  fs.close();
+
+  return true;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeTrips(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  ad::cppgtfs::Writer w;
+  bool hasFreqs = false;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getTripsCsvw(os);
+  csvw.flushLine();
+
+  for (auto t : sourceFeed->getTrips()) {
+    if (t.getFrequencies().size()) hasFreqs = true;
+    w.writeTrip(t.getFlat(), &csvw);
+  }
+
+  return hasFreqs;
+}
+
+// ____________________________________________________________________________
+bool Writer::writeStopTimes(gtfs::Feed* sourceFeed, std::ostream* os) const {
+  std::ifstream fs;
+  fs.open((sourceFeed->getPath() + "/stop_times.txt").c_str());
+
+  CsvParser csvp(&fs);
+  Parser p;
+  ad::cppgtfs::Writer w;
+
+  CsvWriter csvw = ad::cppgtfs::Writer::getStopTimesCsvw(os);
+  csvw.flushLine();
+
+  ad::cppgtfs::gtfs::flat::StopTime st;
+  auto flds = Parser::getStopTimeFlds(&csvp);
+
+  std::string curTripId;
+  Trip* cur = 0;
+
+  while (p.nextStopTime(&csvp, &st, flds)) {
+    // we may have changed to distance field
+    if (curTripId != st.trip) {
+      cur = sourceFeed->getTrips().get(st.trip);
+      curTripId = st.trip;
+    }
+    for (const auto& stN : cur->getStopTimes()) {
+      if (stN.getSeq() == st.sequence)
+        st.shapeDistTravelled = stN.getShapeDistanceTravelled();
+    }
+
+    w.writeStopTime(st, &csvw);
+  }
+  fs.close();
+
+  return true;
+}
+
+// ___________________________________________________________________________
+void Writer::cannotWrite(const std::string& file, const std::string& file2) {
+  std::stringstream ss;
+  ss << "(temporary file for " << file2 << ") Could not write to file";
+  throw ad::cppgtfs::WriterException(ss.str(), file);
+}

src/pfaedle/gtfs/Writer.h

@@ -0,0 +1,41 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef PFAEDLE_GTFS_WRITER_H_
+#define PFAEDLE_GTFS_WRITER_H_
+
+#include <string>
+#include "Feed.h"
+
+namespace pfaedle {
+namespace gtfs {
+
+class Writer {
+ public:
+  Writer() {}
+
+  bool write(Feed* sourceFeed, const std::string& path) const;
+
+ private:
+  bool writeFeedInfo(Feed* f, std::ostream* os) const;
+  bool writeAgency(Feed* f, std::ostream* os) const;
+  bool writeStops(Feed* f, std::ostream* os) const;
+  bool writeRoutes(Feed* f, std::ostream* os) const;
+  bool writeCalendar(Feed* f, std::ostream* os) const;
+  bool writeCalendarDates(Feed* f, std::ostream* os) const;
+  bool writeFrequencies(Feed* f, std::ostream* os) const;
+  bool writeTransfers(Feed* f, std::ostream* os) const;
+  bool writeFares(Feed* f, std::ostream* os) const;
+  bool writeFareRules(Feed* f, std::ostream* os) const;
+  bool writeShapes(Feed* f, std::ostream* os) const;
+  bool writeTrips(Feed* f, std::ostream* os) const;
+  bool writeStopTimes(Feed* f, std::ostream* os) const;
+
+  static void cannotWrite(const std::string& file, const std::string& file2);
+};
+
+}  // namespace gtfs
+}  // namespace pfaedle
+
+#endif  // PFAEDLE_GTFS_WRITER_H_