initial commit

CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required (VERSION 2.8)
+
+project (osmfixer)
+
+if (CMAKE_BUILD_TYPE)
+	string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE)
+endif()
+if (CMAKE_BUILD_TYPE STREQUAL "DEBUG")
+	set(CPPLINT "${CMAKE_SOURCE_DIR}/cpplint.py")
+	include(cmake/cpplint.cmake)
+endif()
+
+set(CPPLINT_PROJECT_ROOT "src")
+
+enable_testing()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/")
+set(EXECUTABLE_OUTPUT_PATH "${CMAKE_SOURCE_DIR}/build")
+
+
+find_package(OpenMP)
+if (OPENMP_FOUND)
+	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
+endif()
+
+
+# set compiler flags, see http://stackoverflow.com/questions/7724569/debug-vs-release-in-cmake
+if(OPENMP_FOUND)
+	set(CMAKE_CXX_FLAGS            "-fopenmp -Ofast -fno-signed-zeros -fno-trapping-math -Wall -Wno-format-extra-args -Wextra -Wformat-nonliteral -Wformat-security -Wformat=2 -Wextra -Wno-implicit-fallthrough -pedantic")
+else()
+	message(WARNING "Configuring without OpenMP!")
+	set(CMAKE_CXX_FLAGS            "-Ofast -fno-signed-zeros -fno-trapping-math -Wall -Wno-format-extra-args -Wextra -Wformat-nonliteral -Wformat-security -Wformat=2 -Wextra -Wno-implicit-fallthrough -pedantic")
+endif()
+set(CMAKE_CXX_FLAGS_DEBUG          "-Og -g -DLOGLEVEL=3")
+set(CMAKE_CXX_FLAGS_MINSIZEREL     "${CMAKE_CXX_FLAGS} -DLOGLEVEL=2")
+set(CMAKE_CXX_FLAGS_RELEASE        "${CMAKE_CXX_FLAGS} -DLOGLEVEL=2")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -g -DLOGLEVEL=3")
+
+# export compile commands to tools like clang
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+# Compiler-specific C++11 activation.
+if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
+	execute_process(
+		COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+	if ((GCC_VERSION VERSION_GREATER 4.8 OR GCC_VERSION VERSION_EQUAL 4.8))
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+	else ()
+		message(FATAL_ERROR "${PROJECT_NAME} requires g++ 4.8 or greater!")
+	endif ()
+elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
+	#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++ -std=c++11")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+else ()
+	message(FATAL_ERROR "Your C++ compiler does not support C++11.")
+endif ()
+
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+
+# http://brianmilco.blogspot.de/2012/11/cmake-automatically-use-git-tags-as.html
+include(GetGitRevisionDescription)
+git_get_tag(VERSION_GIT)
+get_git_is_dirty(VERSION_GIT_IS_DIRTY)
+if ("${VERSION_GIT_IS_DIRTY}" STREQUAL "")
+	set(VERSION_GIT_FULL "${VERSION_GIT}")
+else()
+	set(VERSION_GIT_FULL "${VERSION_GIT}-${VERSION_GIT_IS_DIRTY}")
+endif()
+
+add_subdirectory(src)

cmake/GetGitRevisionDescription.cmake

@@ -0,0 +1,151 @@
+# - Returns a version string from Git
+#
+# These functions force a re-configure on each git commit so that you can
+# trust the values of the variables in your build system.
+#
+#  get_git_head_revision(<refspecvar> <hashvar> [<additional arguments to git describe> ...])
+#
+# Returns the refspec and sha hash of the current head revision
+#
+#  git_describe(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe on the source tree, and adjusting
+# the output so that it tests false if an error occurs.
+#
+#  git_get_exact_tag(<var> [<additional arguments to git describe> ...])
+#
+# Returns the results of git describe --exact-match on the source tree,
+# and adjusting the output so that it tests false if there was no exact
+# matching tag.
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+if(__get_git_revision_description)
+	return()
+endif()
+set(__get_git_revision_description YES)
+
+# We must run the following at "include" time, not at function call time,
+# to find the path to this module rather than the path to a calling list file
+get_filename_component(_gitdescmoddir ${CMAKE_CURRENT_LIST_FILE} PATH)
+
+function(get_git_head_revision _refspecvar _hashvar)
+	set(GIT_PARENT_DIR "${CMAKE_SOURCE_DIR}")
+	set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+	while(NOT EXISTS "${GIT_DIR}")	# .git dir not found, search parent directories
+		set(GIT_PREVIOUS_PARENT "${GIT_PARENT_DIR}")
+		get_filename_component(GIT_PARENT_DIR ${GIT_PARENT_DIR} PATH)
+		if(GIT_PARENT_DIR STREQUAL GIT_PREVIOUS_PARENT)
+			# We have reached the root directory, we are not in git
+			set(${_refspecvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+			set(${_hashvar} "GITDIR-NOTFOUND" PARENT_SCOPE)
+			return()
+		endif()
+		set(GIT_DIR "${GIT_PARENT_DIR}/.git")
+	endwhile()
+	set(GIT_DATA "${CMAKE_CURRENT_BINARY_DIR}/CMakeFiles/git-data")
+	if(NOT EXISTS "${GIT_DATA}")
+		file(MAKE_DIRECTORY "${GIT_DATA}")
+	endif()
+
+	if(NOT EXISTS "${GIT_DIR}/HEAD")
+		return()
+	endif()
+	set(HEAD_FILE "${GIT_DATA}/HEAD")
+	configure_file("${GIT_DIR}/HEAD" "${HEAD_FILE}" COPYONLY)
+
+	configure_file("${_gitdescmoddir}/GetGitRevisionDescription.cmake.in"
+		"${GIT_DATA}/grabRef.cmake"
+		@ONLY)
+	include("${GIT_DATA}/grabRef.cmake")
+
+	set(${_refspecvar} "${HEAD_REF}" PARENT_SCOPE)
+	set(${_hashvar} "${HEAD_HASH}" PARENT_SCOPE)
+endfunction()
+
+function(get_git_is_dirty _var)
+	if(NOT GIT_FOUND)
+		find_package(Git QUIET)
+	endif()
+
+	execute_process(COMMAND
+		"${GIT_EXECUTABLE}"
+        diff-index --name-only HEAD --
+		WORKING_DIRECTORY
+		"${CMAKE_SOURCE_DIR}"
+		RESULT_VARIABLE
+		res
+		OUTPUT_VARIABLE
+		out
+		ERROR_QUIET
+		OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if(NOT res EQUAL 0)
+		set(out "${out}-${res}-NOTFOUND")
+	endif()
+
+    if (NOT "${out}" STREQUAL "")
+        set(IS_DIRTY "dirty")
+    else()
+        set(IS_DIRTY "")
+    endif()
+	set(${_var} "${IS_DIRTY}" PARENT_SCOPE)
+endfunction()
+
+function(git_describe _var)
+	if(NOT GIT_FOUND)
+		find_package(Git QUIET)
+	endif()
+	get_git_head_revision(refspec hash)
+	if(NOT GIT_FOUND)
+		set(${_var} "GIT-NOTFOUND" PARENT_SCOPE)
+		return()
+	endif()
+	if(NOT hash)
+		set(${_var} "HEAD-HASH-NOTFOUND" PARENT_SCOPE)
+		return()
+	endif()
+
+	# TODO sanitize
+	#if((${ARGN}" MATCHES "&&") OR
+	#	(ARGN MATCHES "||") OR
+	#	(ARGN MATCHES "\\;"))
+	#	message("Please report the following error to the project!")
+	#	message(FATAL_ERROR "Looks like someone's doing something nefarious with git_describe! Passed arguments ${ARGN}")
+	#endif()
+
+	#message(STATUS "Arguments to execute_process: ${ARGN}")
+
+	execute_process(COMMAND
+		"${GIT_EXECUTABLE}"
+		describe
+		${hash}
+		${ARGN}
+		WORKING_DIRECTORY
+		"${CMAKE_SOURCE_DIR}"
+		RESULT_VARIABLE
+		res
+		OUTPUT_VARIABLE
+		out
+		ERROR_QUIET
+		OUTPUT_STRIP_TRAILING_WHITESPACE)
+	if(NOT res EQUAL 0)
+		set(out "${out}-${res}-NOTFOUND")
+	endif()
+
+	set(${_var} "${out}" PARENT_SCOPE)
+endfunction()
+
+function(git_get_tag _var)
+	git_describe(out --tags ${ARGN})
+	set(${_var} "${out}" PARENT_SCOPE)
+endfunction()

cmake/GetGitRevisionDescription.cmake.in

@@ -0,0 +1,38 @@
+# 
+# Internal file for GetGitRevisionDescription.cmake
+#
+# Requires CMake 2.6 or newer (uses the 'function' command)
+#
+# Original Author:
+# 2009-2010 Ryan Pavlik <rpavlik@iastate.edu> <abiryan@ryand.net>
+# http://academic.cleardefinition.com
+# Iowa State University HCI Graduate Program/VRAC
+#
+# Copyright Iowa State University 2009-2010.
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+set(HEAD_HASH)
+
+file(READ "@HEAD_FILE@" HEAD_CONTENTS LIMIT 1024)
+
+string(STRIP "${HEAD_CONTENTS}" HEAD_CONTENTS)
+if(HEAD_CONTENTS MATCHES "ref")
+	# named branch
+	string(REPLACE "ref: " "" HEAD_REF "${HEAD_CONTENTS}")
+	if(EXISTS "@GIT_DIR@/${HEAD_REF}")
+		configure_file("@GIT_DIR@/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+	elseif(EXISTS "@GIT_DIR@/logs/${HEAD_REF}")
+		configure_file("@GIT_DIR@/logs/${HEAD_REF}" "@GIT_DATA@/head-ref" COPYONLY)
+		set(HEAD_HASH "${HEAD_REF}")
+	endif()
+else()
+	# detached HEAD
+	configure_file("@GIT_DIR@/HEAD" "@GIT_DATA@/head-ref" COPYONLY)
+endif()
+
+if(NOT HEAD_HASH)
+	file(READ "@GIT_DATA@/head-ref" HEAD_HASH LIMIT 1024)
+	string(STRIP "${HEAD_HASH}" HEAD_HASH)
+endif()

cmake/MacPlistMacros.cmake

@@ -0,0 +1,12 @@
+# Mac Plist Macros
+
+FUNCTION (GET_VERSION_PLIST PLISTFILE OUTVAR)
+	SET (PVERSION "")
+	IF (EXISTS ${PLISTFILE})
+		FILE (READ "${PLISTFILE}" info_plist)
+		STRING (REGEX REPLACE "\n" "" info_plist "${info_plist}")
+		STRING (REGEX MATCH "<key>CFBundleShortVersionString</key>[ \t]*<string>([0-9\\.]*)</string>" PLISTVERSION "${info_plist}")
+		STRING (REGEX REPLACE "<key>CFBundleShortVersionString</key>[ \t]*<string>([0-9\\.]*)</string>" "\\1" PVERSION "${PLISTVERSION}")
+	ENDIF (EXISTS ${PLISTFILE})
+	SET (${OUTVAR} ${PVERSION} PARENT_SCOPE)
+ENDFUNCTION (GET_VERSION_PLIST)

cmake/cpplint.cmake

@@ -0,0 +1,133 @@
+#
+# CMake module to C++ static analysis against 
+# Google C++ Style Guide (https://google.github.io/styleguide/cppguide.html)
+#
+# For more detials please follow links:
+#
+# - https://github.com/google/styleguide
+# - https://pypi.python.org/pypi/cpplint
+# - https://github.com/theandrewdavis/cpplint
+#
+# Copyright (c) 2016 Piotr L. Figlarek
+# 
+# Usage
+# -----
+# Include this module via CMake include(...) command and then add each source directory 
+# via introduced by this module cpplint_add_subdirectory(...) function. Added directory 
+# will be recursivelly scanned and all available files will be checked. 
+#
+# Example
+# -------
+# # include CMake module
+# include(cmake/cpplint.cmake)
+#
+# # add all source code directories
+# cpplint_add_subdirectory(core)
+# cpplint_add_subdirectory(modules/c-bind)
+#
+# License (MIT)
+# -------------
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+# select files extensions to check
+option(CPPLINT_TEST_C_FILES     "Check *.c files"     ON)
+option(CPPLINT_TEST_H_FILES     "Check *.h files"     ON)
+option(CPPLINT_TEST_CPP_FILES   "Check *.cpp files"   ON)
+option(CPPLINT_TEST_HPP_FILES   "Check *.hpp files"   ON)
+option(CPPLINT_TEST_TPP_FILES   "Check *.tpp files"   ON)
+
+# target to run cpplint.py for all configured sources
+set(CPPLINT_TARGET lint CACHE STRING "Name of C++ style checker target") 
+
+# project root directory
+set(CPPLINT_PROJECT_ROOT "${PROJECT_SOURCE_DIR}" CACHE STRING "Project ROOT directory")
+
+
+# find cpplint.py script
+if(CPPLINT)
+    message(STATUS "cpplint parser: ${CPPLINT}")
+else()
+    message(FATAL_ERROR "cpplint script: NOT FOUND! "
+		"Please set the CPPLINT variable.")
+endif()
+
+
+# common target to concatenate all cpplint.py targets
+add_custom_target(${CPPLINT_TARGET} ALL)
+
+
+# use cpplint.py to check source code files inside DIR directory
+function(cpplint_add_subdirectory DIR)
+    # create relative path to the directory
+    set(ABSOLUTE_DIR ${CMAKE_CURRENT_LIST_DIR}/${DIR})
+
+    # add *.c files
+    if(CPPLINT_TEST_C_FILES)
+        set(EXTENSIONS       ${EXTENSIONS}c,)
+        set(FILES_TO_CHECK   ${FILES_TO_CHECK} ${ABSOLUTE_DIR}/*.c)
+    endif()
+
+    # add *.h files
+    if(CPPLINT_TEST_H_FILES)
+        set(EXTENSIONS       ${EXTENSIONS}h,)
+        set(FILES_TO_CHECK   ${FILES_TO_CHECK} ${ABSOLUTE_DIR}/*.h)
+    endif()
+
+    # add *.cpp files
+    if(CPPLINT_TEST_CPP_FILES)
+        set(EXTENSIONS       ${EXTENSIONS}cpp,)
+        set(FILES_TO_CHECK   ${FILES_TO_CHECK} ${ABSOLUTE_DIR}/*.cpp)
+    endif()
+
+    # add *.hpp files
+    if(CPPLINT_TEST_HPP_FILES)
+        set(EXTENSIONS       ${EXTENSIONS}hpp,)
+        set(FILES_TO_CHECK   ${FILES_TO_CHECK} ${ABSOLUTE_DIR}/*.hpp)
+    endif()
+
+    # add *.tpp files
+    if(CPPLINT_TEST_TPP_FILES)
+        set(EXTENSIONS       ${EXTENSIONS}tpp,)
+        set(FILES_TO_CHECK   ${FILES_TO_CHECK} ${ABSOLUTE_DIR}/*.tpp)
+    endif()
+
+    # find all source files inside project
+    file(GLOB_RECURSE LIST_OF_FILES ${FILES_TO_CHECK})
+
+    # create valid target name for this check
+    string(REGEX REPLACE "/" "." TEST_NAME ${DIR})
+    set(TARGET_NAME ${CPPLINT_TARGET}.${TEST_NAME})
+
+    # perform cpplint check
+    add_custom_target(${TARGET_NAME}
+        COMMAND ${CPPLINT} "--extensions=${EXTENSIONS}"
+                           "--root=${CPPLINT_PROJECT_ROOT}"
+						   "--quiet"
+                           ${LIST_OF_FILES}
+        DEPENDS ${LIST_OF_FILES}
+        COMMENT "cpplint: Checking source code style"
+    )
+
+    # run this target when root cpplint.py test is triggered
+    add_dependencies(${CPPLINT_TARGET} ${TARGET_NAME})
+
+    # add this test to CTest
+    add_test(${TARGET_NAME} ${CMAKE_MAKE_PROGRAM} ${TARGET_NAME})
+endfunction()

src/CMakeLists.txt

@@ -0,0 +1,12 @@
+set(OSMFIXER_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR} ${CMAKE_CURRENT_BINARY_DIR})
+
+if (COMMAND cpplint_add_subdirectory)
+	cpplint_add_subdirectory(osmfixer)
+endif()
+
+include_directories(
+	${OSMFIXER_INCLUDE_DIR}
+)
+
+add_subdirectory(util)
+add_subdirectory(osmfixer)

src/osmfixer/CMakeLists.txt

@@ -0,0 +1,19 @@
+file(GLOB_RECURSE osmfixer_SRC *.cpp)
+
+set(osmfixer_main FixerMain.cpp)
+
+list(REMOVE_ITEM osmfixer_SRC ${osmfixer_main})
+
+include_directories(
+	${OSMFIXER_INCLUDE_DIR}
+)
+
+configure_file (
+  "_config.h.in"
+  "_config.h"
+)
+
+add_executable(osmfixer ${osmfixer_main})
+add_library(osmfixer_dep ${osmfixer_SRC})
+
+target_link_libraries(osmfixer osmfixer_dep util ${Boost_LIBRARIES} -lpthread)

src/osmfixer/FixerMain.cpp

@@ -0,0 +1,17 @@
+// Copyright 2019, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <iostream>
+
+// _____________________________________________________________________________
+int main(int argc, char** argv) {
+  // disable output buffering for standard output
+  setbuf(stdout, NULL);
+
+  // initialize randomness
+  srand(time(NULL) + rand());  // NOLINT
+
+
+  std::cout << "Hello." << std::endl;
+}

src/osmfixer/_config.h.in

@@ -0,0 +1,13 @@
+// Copyright 2017
+// Author: Patrick Brosi
+
+#ifndef SRC_PFAEDLE_CONFIG_H_
+#define SRC_PFAEDLE_CONFIG_H_
+
+// version number from cmake version module
+#define VERSION_FULL "@VERSION_GIT_FULL@"
+
+// version number from cmake version module
+#define INSTALL_PREFIX "@CMAKE_INSTALL_PREFIX@"
+
+#endif  // SRC_PFAEDLE_CONFIG_H_N

src/util/CMakeLists.txt

@@ -0,0 +1,12 @@
+file(GLOB_RECURSE util_SRC *.cpp)
+list(REMOVE_ITEM util_SRC TestMain.cpp)
+add_library(util ${util_SRC})
+
+find_package( ZLIB )
+if (ZLIB_FOUND)
+	include_directories( ${ZLIB_INCLUDE_DIRS} )
+	target_link_libraries( util ${ZLIB_LIBRARIES} )
+	add_definitions( -DZLIB_FOUND=${ZLIB_FOUND} )
+endif( ZLIB_FOUND )
+
+add_subdirectory(tests)

src/util/Misc.h

@@ -0,0 +1,136 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_MISC_H_
+#define UTIL_MISC_H_
+
+#include <cmath>
+#include <cstring>
+#include <chrono>
+#include <sstream>
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+
+#define UNUSED(expr) do { (void)(expr); } while (0)
+#define TIME() std::chrono::high_resolution_clock::now()
+#define TOOK(t1, t2) (std::chrono::duration_cast<microseconds>(t2 - t1).count() / 1000.0)
+#define T_START(n)  auto _tstart_##n = std::chrono::high_resolution_clock::now()
+#define T_STOP(n) (std::chrono::duration_cast<microseconds>(std::chrono::high_resolution_clock::now() - _tstart_##n).count() / 1000.0)
+
+namespace util {
+
+// cached first 10 powers of 10
+static int pow10[10] = {
+    1,           10,          100,           1000,          10000,
+    100000,      1000000,     10000000,      100000000,     1000000000};
+
+// _____________________________________________________________________________
+inline uint64_t factorial(uint64_t n) {
+  if (n == 1) return n;
+  return n * factorial(n - 1);
+}
+
+// _____________________________________________________________________________
+inline uint64_t atoul(const char* p) {
+  uint64_t ret = 0;
+
+  while (*p) {
+    ret = ret * 10 + (*p++ - '0');
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+inline bool isFloatingPoint(const std::string& str) {
+  std::stringstream ss(str);
+  double f;
+  ss >> std::noskipws >> f;
+  return ss.eof() && ! ss.fail();
+}
+
+// _____________________________________________________________________________
+inline double atof(const char* p, uint8_t mn) {
+  // this atof implementation works only on "normal" float strings like
+  // 56.445 or -345.00, but should be faster than std::atof
+  double ret = 0.0;
+  bool neg = false;
+  if (*p == '-') {
+    neg = true;
+    p++;
+  }
+
+  while (*p >= '0' && *p <= '9') {
+    ret = ret * 10.0 + (*p - '0');
+    p++;
+  }
+
+  if (*p == '.') {
+    p++;
+    double f = 0;
+    uint8_t n = 0;
+
+    for (; n < mn && *p >= '0' && *p <= '9'; n++, p++) {
+      f = f * 10.0 + (*p - '0');
+    }
+
+    if (n < 10)
+      ret += f / pow10[n];
+    else
+      ret += f / std::pow(10, n);
+  }
+
+  if (neg) return -ret;
+  return ret;
+}
+
+// _____________________________________________________________________________
+inline double atof(const char* p) { return atof(p, 38); }
+
+// _____________________________________________________________________________
+inline std::string getHomeDir() {
+  // parse implicit paths
+  const char* homedir = 0;
+  char* buf = 0;
+
+  if ((homedir = getenv("HOME")) == 0) {
+    homedir = "";
+    struct passwd pwd;
+    struct passwd* result;
+    size_t bufsize;
+    bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
+    if (bufsize == static_cast<size_t>(-1)) bufsize = 0x4000;
+    buf = static_cast<char*>(malloc(bufsize));
+    if (buf != 0) {
+      getpwuid_r(getuid(), &pwd, buf, bufsize, &result);
+      if (result != NULL) homedir = result->pw_dir;
+    }
+  }
+
+  std::string ret(homedir);
+  if (buf) free(buf);
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+inline std::string getTmpDir() {
+  // first, check if an env variable is set
+  const char* tmpdir = getenv("TMPDIR");
+  if (tmpdir && std::strlen(tmpdir)) return std::string(tmpdir);
+
+  // second, check if /tmp is writable
+  if (access("/tmp/", W_OK) == 0) return "/tmp";
+
+  // third, check if the cwd is writable
+  if (access(".", W_OK) == 0)  return ".";
+
+  // lastly, return the users home directory as a fallback
+  return getHomeDir();
+}
+
+}  // namespace util
+
+#endif  // UTIL_MISC_H_

src/util/Nullable.h

@@ -0,0 +1,116 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <stdexcept>
+
+#ifndef UTIL_NULLABLE_H_
+#define UTIL_NULLABLE_H_
+
+namespace util {
+
+template<typename T>
+class Nullable {
+ public:
+  Nullable()
+   : val(), null(true) {}
+  Nullable(T* valPointer)
+   : val(), null(true) {
+   if (valPointer) {
+     assign(*valPointer);
+   }
+  }
+  Nullable(const T& value)
+   : val(value), null(false) {}
+  Nullable(const Nullable& other)
+   : val(other.val), null(other.isNull()) {}
+
+  Nullable& operator=(const Nullable& other) {
+    if (!other.isNull()) val = other.get();
+    null = other.isNull();
+    return *this;
+  }
+
+  T operator=(const T& other) {
+    assign(other);
+    return val;
+  }
+
+  /**
+   * Passing through comparision operators
+   */
+
+  bool operator==(const Nullable& other) const {
+    return (other.isNull() && isNull()) || other.get() == get();
+  }
+
+  bool operator!=(const Nullable& other) const {
+    return !(*this == other);
+  }
+
+  bool operator<(const Nullable& other) const {
+    return !other.isNull() && !isNull() && get() < other.get();
+  }
+
+  bool operator>(const Nullable& other) const {
+    return !(*this < other || *this == other);
+  }
+
+  bool operator<=(const Nullable& other) const {
+    return *this < other || *this == other;
+  }
+
+  bool operator>=(const Nullable& other) const {
+    return *this > other || *this == other;
+  }
+
+  bool operator==(const T& other) const {
+    return !isNull() && other == get();
+  }
+
+  bool operator!=(const T& other) const {
+    return !(*this == other);
+  }
+
+  bool operator<(const T& other) const {
+    return !isNull() && get() < other;
+  }
+
+  bool operator>(const T& other) const {
+    return !(*this < other || *this == other);
+  }
+
+  bool operator<=(const T& other) const {
+    return *this < other || *this == other;
+  }
+
+  bool operator>=(const T& other) const {
+    return *this > other || *this == other;
+  }
+
+  operator T() const {
+    return get();
+  }
+
+  bool isNull() const {
+    return null;
+  }
+
+  T get() const {
+    if (!isNull()) return val;
+    else throw std::runtime_error("Trying to retrieve value of NULL object.");
+  }
+
+private:
+  void assign(T v) {
+    val = v;
+    null = false;
+  }
+
+  T val;
+  bool null;
+};
+
+}
+
+#endif  // UTIL_NULLABLE_H_

src/util/String.h

@@ -0,0 +1,231 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_STRING_H_
+#define UTIL_STRING_H_
+
+#include <algorithm>
+#include <cstring>
+#include <sstream>
+#include <string>
+#include <vector>
+
+namespace util {
+
+// _____________________________________________________________________________
+inline std::string urlDecode(const std::string& encoded) {
+  std::string decoded;
+  for (size_t i = 0; i < encoded.size(); ++i) {
+    char c = encoded[i];
+    if (c == '%') {
+      std::string ah = encoded.substr(i + 1, 2);
+      char* nonProced = 0;
+      char hexVal = strtol(ah.c_str(), &nonProced, 16);
+
+      if (ah.find_first_of("+-") > 1 && ah.size() - strlen(nonProced) == 2) {
+        c = hexVal;
+        i += 2;
+      }
+    } else if (c == '+') {
+      c = ' ';
+    }
+    decoded += c;
+  }
+  return decoded;
+}
+
+// _____________________________________________________________________________
+inline std::string jsonStringEscape(const std::string& unescaped) {
+  std::string escaped;
+  for (size_t i = 0; i < unescaped.size(); ++i) {
+    if (unescaped[i] == '"' || unescaped[i] == '\\') {
+      escaped += "\\";
+    }
+    if (iscntrl(unescaped[i])) {
+      escaped += " ";
+    }
+    escaped += unescaped[i];
+  }
+  return escaped;
+}
+
+// _____________________________________________________________________________
+inline bool replace(std::string& subj, const std::string& from,
+                    const std::string& to) {
+  if (from.empty()) return false;
+  size_t start_pos = subj.find(from);
+  if (start_pos != std::string::npos) {
+    subj.replace(start_pos, from.length(), to);
+    return true;
+  }
+
+  return false;
+}
+
+// _____________________________________________________________________________
+inline bool replaceAll(std::string& subj, const std::string& from,
+                       const std::string& to) {
+  if (from.empty()) return false;
+  bool found = false;
+  size_t s = subj.find(from, 0);
+  for (; s != std::string::npos; s = subj.find(from, s + to.length())) {
+    found = true;
+    subj.replace(s, from.length(), to);
+  }
+
+  return found;
+}
+
+// _____________________________________________________________________________
+inline std::string unixBasename(const std::string& pathname) {
+  return {std::find_if(pathname.rbegin(), pathname.rend(),
+                       [](char c) { return c == '/'; })
+              .base(),
+          pathname.end()};
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline std::string toString(T obj) {
+  std::stringstream ss;
+  ss << obj;
+  return ss.str();
+}
+
+// _____________________________________________________________________________
+inline std::vector<std::string> split(std::string in, char sep) {
+  std::stringstream ss(in);
+  std::vector<std::string> ret(1);
+  while (std::getline(ss, ret.back(), sep)) {
+    ret.push_back("");
+  }
+  ret.pop_back();
+  return ret;
+}
+
+// _____________________________________________________________________________
+inline std::string ltrim(std::string str) {
+  str.erase(0, str.find_first_not_of(" \t\n\v\f\r"));
+  return str;
+}
+
+// _____________________________________________________________________________
+inline std::string rtrim(std::string str) {
+  str.erase(str.find_last_not_of(" \t\n\v\f\r") + 1);
+  return str;
+}
+
+// _____________________________________________________________________________
+inline std::string trim(std::string str) { return ltrim(rtrim(str)); }
+
+// _____________________________________________________________________________
+inline size_t editDist(const std::string& s1, const std::string& s2) {
+  // https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
+  size_t len1 = s1.size();
+  size_t len2 = s2.size();
+  std::vector<size_t> cur(len2 + 1);
+  std::vector<size_t> prev(len2 + 1);
+
+  for (size_t i = 0; i < prev.size(); i++) prev[i] = i;
+
+  for (size_t i = 0; i < len1; i++) {
+    cur[0] = i + 1;
+    for (size_t j = 0; j < len2; j++) {
+      cur[j + 1] =
+          std::min(prev[1 + j] + 1,
+                   std::min(cur[j] + 1, prev[j] + (s1[i] == s2[j] ? 0 : 1)));
+    }
+    std::swap(cur, prev);
+  }
+
+  return prev[len2];
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const std::string& prefix, const std::string& s,
+                             size_t deltaMax) {
+  // https://en.wikibooks.org/wiki/Algorithm_Implementation/Strings/Levenshtein_distance#C++
+  size_t len1 = prefix.size();
+  size_t len2 = std::min(s.size(), prefix.size() + deltaMax + 1);
+  std::vector<size_t> d((len1 + 1) * (len2 + 1));
+
+  d[0] = 0;
+  for (size_t i = 1; i <= len1; ++i) d[i * (len2 + 1)] = i;
+  for (size_t i = 1; i <= len2; ++i) d[ i] = i;
+
+  for (size_t i = 1; i <= len1; i++) {
+    for (size_t j = 1; j <= len2; j++) {
+      d[i * (len2 + 1) + j] = std::min(std::min(d[(i - 1) * (len2 + 1) + j] + 1, d[i * (len2 + 1) + j - 1] + 1),
+                         d[(i - 1) * (len2 + 1) + j - 1] + (prefix[i - 1] == s[j - 1] ? 0 : 1));
+    }
+  }
+
+  // take min of last row
+  size_t deltaMin = std::max(std::max(deltaMax + 1, prefix.size()), s.size());
+  for (size_t i = 0; i <= len2; i++) {
+    if (d[len1 * (len2 + 1) + i] < deltaMin) deltaMin = d[len1 * (len2 + 1) + i];
+  }
+
+  return deltaMin;
+}
+
+// _____________________________________________________________________________
+inline size_t prefixEditDist(const std::string& prefix, const std::string& s) {
+  return prefixEditDist(prefix, s, s.size());
+}
+
+// _____________________________________________________________________________
+inline std::string toUpper(std::string str) {
+  std::transform(str.begin(), str.end(),str.begin(), toupper);
+  return str;
+}
+
+// _____________________________________________________________________________
+inline std::string toLower(std::string str) {
+  std::transform(str.begin(), str.end(),str.begin(), tolower);
+  return str;
+}
+
+// _____________________________________________________________________________
+template <class Iter>
+inline std::string implode(Iter begin, const Iter& end, const char* del) {
+  std::stringstream ss;
+  size_t i = 0;
+  while (begin != end) {
+    if (i != 0) ss << del;
+    ss << *begin;
+    begin++;
+    i++;
+  }
+
+  return ss.str();
+}
+
+// _____________________________________________________________________________
+inline std::string normalizeWhiteSpace(const std::string& input) {
+  std::string ret;
+  bool ws = false;
+  for (size_t i = 0; i < input.size(); i++) {
+    if (std::isspace(input[i])) {
+      if (!ws) {
+        ret += " ";
+        ws = true;
+      }
+      continue;
+    } else {
+      ws = false;
+      ret += input[i];
+    }
+  }
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+inline std::string implode(const std::vector<T>& vec, const char* del) {
+  return implode(vec.begin(), vec.end(), del);
+}
+}
+
+#endif  // UTIL_STRING_H_

src/util/geo/BezierCurve.h

@@ -0,0 +1,54 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_BEZIERCURVE_H_
+#define UTIL_GEO_BEZIERCURVE_H_
+
+#include <vector>
+#include "util/geo/Geo.h"
+#include "util/geo/PolyLine.h"
+
+namespace util {
+namespace geo {
+
+struct CubicPolynom {
+  CubicPolynom(double a, double b, double c, double d, double x)
+      : a(a), b(b), c(c), d(d), x(x) {}
+  CubicPolynom() : a(0), b(0), c(0), d(0), x(0) {}
+  double a, b, c, d, x;
+
+  double valueAt(double x) const;
+};
+
+/**
+ * Bezier curve
+ */
+template <typename T>
+class BezierCurve {
+ public:
+  BezierCurve(const Point<T>& a, const Point<T>& b, const Point<T>& c, const Point<T>& d);
+
+  const PolyLine<T>& render(double d);
+
+ private:
+  double _d;
+
+  // the x and y polynoms for this spline
+  CubicPolynom _xp, _yp;
+
+  // store the rendered polyline for quicker access
+  PolyLine<T> _rendered;
+  bool _didRender;
+
+  void recalcPolynoms(const Point<T>& x, const Point<T>& b, const Point<T>& c,
+                      const Point<T>& d);
+
+  Point<T> valueAt(double t) const;
+};
+
+#include "util/geo/BezierCurve.tpp"
+}
+}
+
+#endif  // UTIL_GEO_BEZIERCURVE_H_

src/util/geo/BezierCurve.tpp

@@ -0,0 +1,70 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename T>
+BezierCurve<T>::BezierCurve(const Point<T>& a, const Point<T>& b,
+                            const Point<T>& c, const Point<T>& d)
+    : _d(dist(a, d)) {
+  assert(_d > 0);
+  recalcPolynoms(a, b, c, d);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void BezierCurve<T>::recalcPolynoms(const Point<T>& a, const Point<T>& b,
+                                    const Point<T>& c, const Point<T>& d) {
+  _xp.a = a.getX();
+  _xp.b = 3.0 * (b.getX() - a.getX());
+  _xp.c = 3.0 * (c.getX() - b.getX()) - _xp.b;
+  _xp.d = d.getX() - a.getX() - _xp.c - _xp.b;
+
+  _yp.a = a.getY();
+  _yp.b = 3.0 * (b.getY() - a.getY());
+  _yp.c = 3.0 * (c.getY() - b.getY()) - _yp.b;
+  _yp.d = d.getY() - a.getY() - _yp.c - _yp.b;
+
+  _didRender = false;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> BezierCurve<T>::valueAt(double t) const {
+  return Point<T>(_xp.valueAt(t), _yp.valueAt(t));
+}
+
+// _____________________________________________________________________________
+template <typename T>
+const PolyLine<T>& BezierCurve<T>::render(double d) {
+  assert(d > 0);
+  if (_didRender) return _rendered;
+
+  if (_d == 0) {
+    _rendered << Point<T>(_xp.a, _yp.a) << Point<T>(_xp.a, _yp.a);
+    return _rendered;
+  }
+
+  _rendered.empty();
+  double n = _d / d, dt = 1 / n, t = 0;
+
+  bool cancel = false;
+  while (true) {
+    _rendered << valueAt(t);
+    t += dt;
+    if (cancel) break;
+    if (t > 1) {
+      t = 1;
+      cancel = true;
+    }
+  }
+
+  _didRender = true;
+  return _rendered;
+}
+
+// _____________________________________________________________________________
+double CubicPolynom::valueAt(double atx) const {
+  double dx = atx - x;
+  return a + b * dx + c * dx * dx + d * dx * dx * dx;
+}

src/util/geo/Box.h

@@ -0,0 +1,91 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_BOX_H_
+#define UTIL_GEO_BOX_H_
+
+#include "./Point.h"
+
+namespace util {
+namespace geo {
+
+template <typename T>
+class Box {
+ public:
+  // maximum inverse box as default value of box
+  Box()
+      : _ll(std::numeric_limits<T>::max(), std::numeric_limits<T>::max()),
+        _ur(std::numeric_limits<T>::lowest(), std::numeric_limits<T>::lowest()) {}
+  Box(const Point<T>& ll, const Point<T>& ur) : _ll(ll), _ur(ur) {}
+  const Point<T>& getLowerLeft() const { return _ll; }
+  const Point<T>& getUpperRight() const { return _ur; }
+
+  Point<T>& getLowerLeft() { return _ll; }
+  Point<T>& getUpperRight() { return _ur; }
+
+  void setLowerLeft(const Point<T>& ll) { _ll = ll; }
+  void setUpperRight(const Point<T>& ur) { _ur = ur; }
+
+  bool operator==(const Box<T>& b) const {
+    return getLowerLeft() == b.getLowerLeft() &&
+           getUpperRight() == b.getUpperRight();
+  }
+
+  bool operator!=(const Box<T>& p) const { return !(*this == p); }
+
+ private:
+  Point<T> _ll, _ur;
+};
+
+template <typename T>
+class RotatedBox {
+ public:
+  RotatedBox() : _box(), _deg(0), _center() {}
+  RotatedBox(const Box<T>& box)
+      : _box(box),
+        _deg(0),
+        _center(Point<T>(
+            (box.getUpperRight().getX() - box.getLowerLeft().getX()) / T(2),
+            (box.getUpperRight().getY() - box.getLowerLeft().getY()) / T(2))) {}
+  RotatedBox(const Point<T>& ll, const Point<T>& ur)
+      : _box(ll, ur),
+        _deg(0),
+        _center(Point<T>((ur.getX() - ll.getX()) / T(2),
+                         (ur.getY() - ll.getY()) / T(2))) {}
+  RotatedBox(const Box<T>& box, double deg)
+      : _box(box),
+        _deg(deg),
+        _center(Point<T>(
+            (box.getUpperRight().getX() - box.getLowerLeft().getX()) / T(2),
+            (box.getUpperRight().getY() - box.getLowerLeft().getY()) / T(2))) {}
+  RotatedBox(const Point<T>& ll, const Point<T>& ur, double deg)
+      : _box(ll, ur),
+        _deg(deg),
+        _center(Point<T>((ur.getX() - ll.getX()) / T(2),
+                         (ur.getY() - ll.getY()) / T(2))) {}
+  RotatedBox(const Box<T>& box, double deg, const Point<T>& center)
+      : _box(box), _deg(deg), _center(center) {}
+  RotatedBox(const Point<T>& ll, const Point<T>& ur, double deg,
+             const Point<T>& center)
+      : _box(ll, ur), _deg(deg), _center(center) {}
+
+  const Box<T>& getBox() const { return _box; }
+  Box<T>& getBox() { return _box; }
+
+  double getDegree() const { return _deg; }
+  const Point<T>& getCenter() const { return _center; }
+  Point<T>& getCenter() { return _center; }
+
+  void setDegree(double deg) { _deg = deg; }
+
+ private:
+  Box<T> _box;
+  double _deg;
+  Point<T> _center;
+};
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_BOX_H_

src/util/geo/GeoGraph.h

@@ -0,0 +1,32 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEOGRAPH_H_
+#define UTIL_GEOGRAPH_H_
+
+#include <map>
+#include "util/geo/Geo.h"
+#include "util/json/Writer.h"
+
+namespace util {
+namespace geograph {
+
+template<typename T>
+class GeoEdgePL {
+ public:
+  virtual const util::geo::Line<T>* getGeom() const = 0;
+  virtual json::Dict getAttrs() const = 0;
+};
+
+template<typename T>
+class GeoNodePL {
+ public:
+  virtual const util::geo::Point<T>* getGeom() const = 0;
+  virtual json::Dict getAttrs() const = 0;
+};
+
+}  // namespace geograph
+}  // namespace util
+
+#endif  // UTIL_GEOGRAPH_H_

src/util/geo/Grid.h

@@ -0,0 +1,89 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_GRID_H_
+#define UTIL_GEO_GRID_H_
+
+#include <set>
+#include <vector>
+#include <map>
+#include "util/geo/Geo.h"
+
+namespace util {
+namespace geo {
+
+class GridException : public std::runtime_error {
+ public:
+  GridException(std::string const& msg) : std::runtime_error(msg) {}
+};
+
+template <typename V, template <typename> class G, typename T>
+class Grid {
+ public:
+  // initialization of a point grid with cell width w and cell height h
+  // that covers the area of bounding box bbox
+  Grid(double w, double h, const Box<T>& bbox);
+
+  // initialization of a point grid with cell width w and cell height h
+  // that covers the area of bounding box bbox
+  // optional parameters specifies whether a value->cell index
+  // should be kept (true by default!)
+  Grid(double w, double h, const Box<T>& bbox, bool buildValIdx);
+
+  // the empty grid
+  Grid();
+  // the empty grid
+  Grid(bool buildValIdx);
+
+  // add object t to this grid
+  void add(G<T> geom, V val);
+  void add(size_t x, size_t y, V val);
+
+  void get(const Box<T>& btbox, std::set<V>* s) const;
+  void get(const G<T>& geom, double d, std::set<V>* s) const;
+  void get(size_t x, size_t y, std::set<V>* s) const;
+  void remove(V val);
+
+  void getNeighbors(const V& val, double d, std::set<V>* s) const;
+  void getCellNeighbors(const V& val, size_t d, std::set<V>* s) const;
+  void getCellNeighbors(size_t x, size_t y, size_t xPerm, size_t yPerm,
+                        std::set<V>* s) const;
+
+  std::set<std::pair<size_t, size_t> > getCells(const V& val) const;
+
+  size_t getXWidth() const;
+  size_t getYHeight() const;
+
+ private:
+  double _width;
+  double _height;
+
+  double _cellWidth;
+  double _cellHeight;
+
+  Box<T> _bb;
+
+  size_t _counter;
+
+  size_t _xWidth;
+  size_t _yHeight;
+
+  bool _hasValIdx;
+
+  std::vector<std::vector<std::set<V> > > _grid;
+  std::map<V, std::set<std::pair<size_t, size_t> > > _index;
+  std::set<V> _removed;
+
+  Box<T> getBox(size_t x, size_t y) const;
+
+  size_t getCellXFromX(double lon) const;
+  size_t getCellYFromY(double lat) const;
+};
+
+#include "util/geo/Grid.tpp"
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_GRID_H_

src/util/geo/Grid.tpp

@@ -0,0 +1,228 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosip@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+Grid<V, G, T>::Grid(bool bldIdx)
+    : _width(0),
+      _height(0),
+      _cellWidth(0),
+      _cellHeight(0),
+      _xWidth(0),
+      _yHeight(0),
+      _hasValIdx(bldIdx) {}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+Grid<V, G, T>::Grid() : Grid<V, G, T>(true) {}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+Grid<V, G, T>::Grid(double w, double h, const Box<T>& bbox)
+    : Grid<V, G, T>(w, h, bbox, true) {}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+Grid<V, G, T>::Grid(double w, double h, const Box<T>& bbox, bool bValIdx)
+    : _cellWidth(fabs(w)),
+      _cellHeight(fabs(h)),
+      _bb(bbox),
+      _hasValIdx(bValIdx) {
+  _width =
+      bbox.getUpperRight().getX() - bbox.getLowerLeft().getX();
+  _height =
+      bbox.getUpperRight().getY() - bbox.getLowerLeft().getY();
+
+  if (_width < 0 || _height < 0) {
+    _width = 0;
+    _height = 0;
+    _xWidth = 0;
+    _yHeight = 0;
+    return;
+  }
+
+  _xWidth = ceil(_width / _cellWidth);
+  _yHeight = ceil(_height / _cellHeight);
+
+  // resize rows
+  _grid.resize(_xWidth);
+
+  // resize columns
+  for (size_t i = 0; i < _xWidth; i++) {
+    _grid[i].resize(_yHeight);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::add(G<T> geom, V val) {
+  Box<T> box = getBoundingBox(geom);
+  size_t swX = getCellXFromX(box.getLowerLeft().getX());
+  size_t swY = getCellYFromY(box.getLowerLeft().getY());
+
+  size_t neX = getCellXFromX(box.getUpperRight().getX());
+  size_t neY = getCellYFromY(box.getUpperRight().getY());
+
+  for (size_t x = swX; x <= neX && x < _grid.size(); x++) {
+    for (size_t y = swY; y <= neY && y < _grid[x].size(); y++) {
+      if (intersects(geom, getBox(x, y))) {
+        add(x, y, val);
+      }
+    }
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::add(size_t x, size_t y, V val) {
+  _grid[x][y].insert(val);
+  if (_hasValIdx) _index[val].insert(std::pair<size_t, size_t>(x, y));
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::get(const Box<T>& box, std::set<V>* s) const {
+  size_t swX = getCellXFromX(box.getLowerLeft().getX());
+  size_t swY = getCellYFromY(box.getLowerLeft().getY());
+
+  size_t neX = getCellXFromX(box.getUpperRight().getX());
+  size_t neY = getCellYFromY(box.getUpperRight().getY());
+
+  for (size_t x = swX; x <= neX && x >= 0 && x < _xWidth; x++)
+    for (size_t y = swY; y <= neY && y >= 0 && y < _yHeight; y++) get(x, y, s);
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::get(const G<T>& geom, double d, std::set<V>* s) const {
+  Box<T> a = getBoundingBox(geom);
+  Box<T> b(Point<T>(a.getLowerLeft().getX() - d,
+                    a.getLowerLeft().getY() - d),
+           Point<T>(a.getUpperRight().getX() + d,
+                    a.getUpperRight().getY() + d));
+  return get(b, s);
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::get(size_t x, size_t y, std::set<V>* s) const {
+  if (_hasValIdx) {
+    s->insert(_grid[x][y].begin(), _grid[x][y].end());
+  } else {
+    // if we dont have a value index, we have a set of deleted nodes.
+    // in this case, only insert if not deleted
+    std::copy_if(_grid[x][y].begin(), _grid[x][y].end(),
+                 std::inserter(*s, s->end()),
+                 [&](const V& v) { return Grid<V, G, T>::_removed.count(v) == 0; });
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::remove(V val) {
+  if (_hasValIdx) {
+    auto i = _index.find(val);
+    if (i == _index.end()) return;
+
+    for (auto pair : i->second) {
+      _grid[pair.first][pair.second].erase(
+          _grid[pair.first][pair.second].find(val));
+    }
+
+    _index.erase(i);
+  } else {
+    _removed.insert(val);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::getNeighbors(const V& val, double d, std::set<V>* s) const {
+  if (!_hasValIdx) throw GridException("No value index build!");
+  auto it = _index.find(val);
+  if (it == _index.end()) return;
+
+  size_t xPerm = ceil(d / _cellWidth);
+  size_t yPerm = ceil(d / _cellHeight);
+
+  for (auto pair : it->second) {
+    getCellNeighbors(pair.first, pair.second, xPerm, yPerm, s);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::getCellNeighbors(const V& val, size_t d,
+                                     std::set<V>* s) const {
+  if (!_hasValIdx) throw GridException("No value index build!");
+  auto it = _index.find(val);
+  if (it == _index.end()) return;
+
+  for (auto pair : it->second) {
+    getCellNeighbors(pair.first, pair.second, d, d, s);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+void Grid<V, G, T>::getCellNeighbors(size_t cx, size_t cy, size_t xPerm,
+                                     size_t yPerm, std::set<V>* s) const {
+  size_t swX = xPerm > cx ? 0 : cx - xPerm;
+  size_t swY = yPerm > cy ? 0 : cy - yPerm;
+
+  size_t neX = xPerm + cx + 1 > _xWidth ? _xWidth : cx + xPerm + 1;
+  size_t neY = yPerm + cy + 1 > _yHeight ? _yHeight : cy + yPerm + 1;
+
+  for (size_t x = swX; x < neX; x++) {
+    for (size_t y = swY; y < neY; y++) {
+      s->insert(_grid[x][y].begin(), _grid[x][y].end());
+    }
+  }
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+std::set<std::pair<size_t, size_t> > Grid<V, G, T>::getCells(
+    const V& val) const {
+  if (!_hasValIdx) throw GridException("No value index build!");
+  return _index.find(val)->second;
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+Box<T> Grid<V, G, T>::getBox(size_t x, size_t y) const {
+  Point<T> sw(_bb.getLowerLeft().getX() + x * _cellWidth,
+              _bb.getLowerLeft().getY() + y * _cellHeight);
+  Point<T> ne(_bb.getLowerLeft().getX() + (x + 1) * _cellWidth,
+              _bb.getLowerLeft().getY() + (y + 1) * _cellHeight);
+  return Box<T>(sw, ne);
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+size_t Grid<V, G, T>::getCellXFromX(double x) const {
+  float dist = x - _bb.getLowerLeft().getX();
+  if (dist < 0) dist = 0;
+  return floor(dist / _cellWidth);
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+size_t Grid<V, G, T>::getCellYFromY(double y) const {
+  float dist = y - _bb.getLowerLeft().getY();
+  if (dist < 0) dist = 0;
+  return floor(dist / _cellHeight);
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+size_t Grid<V, G, T>::getXWidth() const {
+  return _xWidth;
+}
+
+// _____________________________________________________________________________
+template <typename V, template <typename> class G, typename T>
+size_t Grid<V, G, T>::getYHeight() const {
+  return _yHeight;
+}

src/util/geo/Line.h

@@ -0,0 +1,28 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_LINE_H_
+#define UTIL_GEO_LINE_H_
+
+#include <vector>
+#include "./Point.h"
+
+namespace util {
+namespace geo {
+
+template <typename T>
+class Line : public std::vector<Point<T>> {
+  using std::vector<Point<T>>::vector;
+};
+
+template <typename T>
+using LineSegment = std::pair<Point<T>, Point<T>>;
+
+template <typename T>
+using MultiLine = std::vector<Line<T>>;
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_LINE_H_

src/util/geo/Point.h

@@ -0,0 +1,50 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_POINT_H_
+#define UTIL_GEO_POINT_H_
+
+#include <vector>
+
+namespace util {
+namespace geo {
+
+template <typename T>
+class Point {
+ public:
+  Point() : _x(0), _y(0) {}
+  Point(T x, T y) : _x(x), _y(y) {}
+  T getX() const { return _x; }
+  T getY() const { return _y; }
+
+  void setX(T x) { _x = x; }
+  void setY(T y) { _y = y; }
+
+  Point<T> operator+(const Point<T>& p) const {
+    return Point<T>(_x + p.getX(), _y + p.getY());
+  }
+
+  Point<T> operator-(const Point<T>& p) const {
+    return Point<T>(_x - p.getX(), _y - p.getY());
+  }
+
+  bool operator==(const Point<T>& p) const {
+    return p.getX() == _x && p.getY() == _y;
+  }
+
+  bool operator!=(const Point<T>& p) const {
+    return !(*this == p);
+  }
+
+ private:
+  T _x, _y;
+};
+
+template <typename T>
+using MultiPoint = std::vector<Point<T>>;
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_POINT_H_

src/util/geo/PolyLine.h

@@ -0,0 +1,143 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_POLYLINE_H_
+#define UTIL_GEO_POLYLINE_H_
+
+#include <cfloat>
+#include <ostream>
+#include <iomanip>
+#include <string>
+#include <set>
+#include <vector>
+#include "Geo.h"
+
+namespace util {
+namespace geo {
+
+static const double MAX_EQ_DISTANCE = 15;
+static const double AVERAGING_STEP = 20;
+
+// legacy code, will be removed in the future
+
+template <typename T>
+struct LinePoint {
+  LinePoint() : lastIndex(0), totalPos(-1), p() {}
+
+  LinePoint(size_t i, double pos, const Point<T>& p)
+      : lastIndex(i), totalPos(pos), p(p) {}
+  size_t lastIndex;
+  double totalPos;
+  Point<T> p;
+};
+
+template <typename T>
+struct LinePointCmp {
+  bool operator()(const LinePoint<T>& lh, const LinePoint<T>& rh) const {
+    return lh.totalPos < rh.totalPos;
+  }
+};
+
+
+template <typename T>
+using LinePointPair = std::pair<LinePoint<T>, LinePoint<T>>;
+template <typename T>
+using SharedSegment = std::pair<LinePointPair<T>, LinePointPair<T>>;
+
+template <typename T>
+struct SharedSegments {
+  std::vector<SharedSegment<T>> segments;
+};
+
+template <typename T>
+class PolyLine {
+ public:
+  PolyLine();
+  PolyLine(const Point<T>& from, const Point<T>& to);
+  PolyLine(const Line<T>& l);
+
+  PolyLine& operator<<(const Point<T>& p);
+  PolyLine& operator>>(const Point<T>& p);
+
+  void reverse();
+  PolyLine getReversed() const;
+
+  void offsetPerp(double units);
+
+  PolyLine getPerpOffsetted(double units) const;
+
+  const Line<T>& getLine() const;
+
+  double distTo(const PolyLine<T>& g) const;
+  double distTo(const Point<T>& p) const;
+
+  SharedSegments<T> getSharedSegments(const PolyLine<T>& pl, double dmax) const;
+
+  double getLength() const;
+
+  // return point at dist
+  LinePoint<T> getPointAtDist(double dist) const;
+
+  // return point at [0..1]
+  LinePoint<T> getPointAt(double dist) const;
+
+  PolyLine<T> getSegment(double a, double b) const;
+  PolyLine<T> getSegmentAtDist(double dista, double distb) const;
+  PolyLine<T> getSegment(const LinePoint<T>& start, const LinePoint<T>& end) const;
+  PolyLine<T> getSegment(const Point<T>& a, const Point<T>& b) const;
+
+  std::set<LinePoint<T>, LinePointCmp<T>> getIntersections(const PolyLine<T>& g) const;
+
+  static PolyLine<T> average(const std::vector<const PolyLine<T>*>& lines);
+  static PolyLine<T> average(const std::vector<const PolyLine<T>*>& lines,
+                          const std::vector<double>& weights);
+
+  void simplify(double d);
+  void empty();
+
+  void smoothenOutliers(double d);
+
+  std::pair<size_t, double> nearestSegment(const Point<T>& p) const;
+  std::pair<size_t, double> nearestSegmentAfter(const Point<T>& p,
+                                                size_t after) const;
+
+  LinePoint<T> projectOn(const Point<T>& p) const;
+  LinePoint<T> projectOnAfter(const Point<T>& p, size_t after) const;
+
+  void move(double vx, double vy);
+
+  std::pair<double, double> getSlopeBetween(double ad, double bd) const;
+  std::pair<double, double> getSlopeBetweenDists(double ad, double bd) const;
+
+  // equality operator, will hold frechet-distance equality check in
+  // the dmax
+  bool operator==(const PolyLine& rhs) const;
+  bool contains(const PolyLine& rhs, double dmax) const;
+  bool equals(const PolyLine& rhs) const;
+  bool equals(const PolyLine& rhs, double dmax) const;
+
+  std::string getWKT() const;
+
+  PolyLine getOrthoLineAtDist(double d, double lengt) const;
+
+  Point<T> interpolate(const Point<T>& a, const Point<T>& b, double p) const;
+
+  void fixTopology(double maxl);
+  void applyChaikinSmooth(size_t depth);
+
+  const Point<T>& front() const;
+  const Point<T>& back() const;
+
+ private:
+  std::set<LinePoint<T>, LinePointCmp<T>> getIntersections(const PolyLine& p,
+                                                     size_t a, size_t b) const;
+  Line<T> _line;
+};
+
+#include "util/geo/PolyLine.tpp"
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_POLYLINE_H_

src/util/geo/PolyLine.tpp

@@ -0,0 +1,731 @@
+// Copyright 2016, University of Freibur
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T>::PolyLine() {}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T>::PolyLine(const Point<T>& from, const Point<T>& to) {
+  *this << from << to;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T>::PolyLine(const Line<T>& l) : _line(l) {}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T>& PolyLine<T>::operator<<(const Point<T>& p) {
+  _line.push_back(p);
+  return *this;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T>& PolyLine<T>::operator>>(const Point<T>& p) {
+  _line.insert(_line.begin(), p);
+  return *this;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::reverse() {
+  std::reverse(_line.begin(), _line.end());
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getReversed() const {
+  PolyLine ret = *this;
+  ret.reverse();
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+const Line<T>& PolyLine<T>::getLine() const {
+  return _line;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getPerpOffsetted(double units) const {
+  PolyLine p = *this;
+  p.offsetPerp(units);
+  return p;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::offsetPerp(double units) {
+  /*
+   * calculate perpendicular offset of a polyline
+   *
+   * there doesn't seem to be any library which reliably does that,
+   * so we do it ourself here until we find one...
+   */
+
+  if (fabs(units) < 0.001) return;
+
+  assert(getLength() > 0);
+
+  if (_line.size() < 2) return;
+
+  Line<T> ret;
+  Point<T> lastP = _line.front();
+
+  Point<T> *lastIns = 0, *befLastIns = 0;
+
+  for (size_t i = 1; i < _line.size(); i++) {
+    Point<T> curP = _line[i];
+
+    double n1 = lastP.getY() - curP.getY();
+    double n2 = curP.getX() - lastP.getX();
+    double n = sqrt(n1 * n1 + n2 * n2);
+
+    // if n == 0, the segment is effectively a point
+    // we would get into all sorts of troubles if we tried to offset a point...
+    if (!(n > 0)) continue;
+
+    n1 = n1 / n;
+    n2 = n2 / n;
+
+    lastP.setX(lastP.getX() + (n1 * units));
+    lastP.setY(lastP.getY() + (n2 * units));
+
+    curP.setX(curP.getX() + (n1 * units));
+    curP.setY(curP.getY() + (n2 * units));
+
+    if (lastIns && befLastIns &&
+        lineIntersects(*lastIns, *befLastIns, lastP, curP)) {
+      *lastIns = intersection(*lastIns, *befLastIns, lastP, curP);
+
+      double d = dist(lastP, *lastIns);
+      double d2 = distToSegment(*lastIns, *befLastIns, lastP);
+
+      if (d > fabs(units) * 2 && d2 < d - (fabs(units))) {
+        PolyLine pl(*lastIns, *befLastIns);
+        PolyLine pll(*lastIns, curP);
+        pl = pl.getSegment(0, (d - (fabs(units))) / pl.getLength());
+        pll = pll.getSegment(0, (d - (fabs(units))) / pll.getLength());
+
+        ret.push_back(pll.back());
+        *lastIns = pl.back();
+
+        ret.push_back(curP);
+      } else {
+        ret.push_back(curP);
+      }
+    } else {
+      ret.push_back(lastP);
+      ret.push_back(curP);
+    }
+
+    lastIns = &ret[ret.size() - 1];
+    befLastIns = &ret[ret.size() - 2];
+
+    lastP = _line[i];
+  }
+
+  _line = ret;
+
+  // heuristics
+  simplify(1);
+  fixTopology(fabs(2 * 3.14 * units));
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getSegment(double a, double b) const {
+  if (a > b) {
+    double c = a;
+    a = b;
+    b = c;
+  }
+  LinePoint<T> start = getPointAt(a);
+  LinePoint<T> end = getPointAt(b);
+
+  return getSegment(start, end);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getSegmentAtDist(double a, double b) const {
+  if (a > b) {
+    double c = a;
+    a = b;
+    b = c;
+  }
+  LinePoint<T> start = getPointAtDist(a);
+  LinePoint<T> end = getPointAtDist(b);
+
+  return getSegment(start, end);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getSegment(const Point<T>& a,
+                                    const Point<T>& b) const {
+  LinePoint<T> start = projectOn(a);
+  LinePoint<T> end = projectOnAfter(b, start.lastIndex);
+
+  return getSegment(start, end);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getSegment(const LinePoint<T>& start,
+                                    const LinePoint<T>& end) const {
+  PolyLine ret;
+  ret << start.p;
+
+  if (start.lastIndex + 1 <= end.lastIndex) {
+    ret._line.insert(ret._line.end(), _line.begin() + start.lastIndex + 1,
+                     _line.begin() + end.lastIndex + 1);
+  }
+  ret << end.p;
+
+  // find a more performant way to clear the result of above
+  ret.simplify(0);
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+LinePoint<T> PolyLine<T>::getPointAtDist(double atDist) const {
+  if (atDist > getLength()) atDist = getLength();
+  if (atDist < 0) atDist = 0;
+
+  double dist = 0;
+
+  if (_line.size() == 1) return LinePoint<T>(0, 0, _line[0]);
+
+  const Point<T>* last = &_line[0];
+
+  for (size_t i = 1; i < _line.size(); i++) {
+    const Point<T>& cur = _line[i];
+    double d = geo::dist(*last, cur);
+    dist += d;
+
+    if (dist > atDist) {
+      double p = (d - (dist - atDist));
+      return LinePoint<T>(i - 1, atDist / getLength(),
+                          interpolate(*last, cur, p));
+    }
+
+    last = &_line[i];
+  }
+
+  return LinePoint<T>(_line.size() - 1, 1, _line.back());
+}
+
+// _____________________________________________________________________________
+template <typename T>
+LinePoint<T> PolyLine<T>::getPointAt(double at) const {
+  at *= getLength();
+  return getPointAtDist(at);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+Point<T> PolyLine<T>::interpolate(const Point<T>& a, const Point<T>& b,
+                                  double p) const {
+  double n1 = b.getX() - a.getX();
+  double n2 = b.getY() - a.getY();
+  double n = sqrt(n1 * n1 + n2 * n2);
+  n1 = n1 / n;
+  n2 = n2 / n;
+  return Point<T>(a.getX() + (n1 * p),
+                  a.getY() + (n2 * p));
+}
+
+// _____________________________________________________________________________
+template <typename T>
+double PolyLine<T>::distTo(const PolyLine<T>& g) const {
+  return dist(_line, g.getLine());
+}
+
+// _____________________________________________________________________________
+template <typename T>
+double PolyLine<T>::distTo(const Point<T>& p) const {
+  return dist(_line, p);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+double PolyLine<T>::getLength() const {
+  return len(_line);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::average(const std::vector<const PolyLine<T>*>& lines,
+                                 const std::vector<double>& weights) {
+  bool weighted = lines.size() == weights.size();
+  double stepSize;
+
+  double longestLength = DBL_MIN;  // avoid recalc of length on each comparision
+  for (const PolyLine* p : lines) {
+    if (p->getLength() > longestLength) {
+      longestLength = p->getLength();
+    }
+  }
+
+  PolyLine ret;
+  double total = 0;
+
+  for (size_t i = 0; i < lines.size(); ++i) {
+    if (weighted) {
+      total += weights[i];
+    } else {
+      total += 1;
+    }
+  }
+
+  stepSize = AVERAGING_STEP / longestLength;
+  bool end = false;
+  for (double a = 0; !end; a += stepSize) {
+    if (a > 1) {
+      a = 1;
+      end = true;
+    }
+    double x = 0, y = 0;
+
+    for (size_t i = 0; i < lines.size(); ++i) {
+      const PolyLine* pl = lines[i];
+      Point<T> p = pl->getPointAt(a).p;
+      if (weighted) {
+        x += p.getX() * weights[i];
+        y += p.getY() * weights[i];
+      } else {
+        x += p.getX();
+        y += p.getY();
+      }
+    }
+    ret << Point<T>(x / total, y / total);
+  }
+
+  ret.simplify(0);
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::average(const std::vector<const PolyLine<T>*>& lines) {
+  return average(lines, std::vector<double>());
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::pair<size_t, double> PolyLine<T>::nearestSegmentAfter(const Point<T>& p,
+                                                           size_t a) const {
+  // returns the index of the starting point of the nearest segment of p
+  assert(a < _line.size());
+
+  double totalLength = getLength();
+  size_t smallest = a;
+  double totalDist = 0;
+  double dist = DBL_MAX;
+  double smallestDist = 0;
+
+  for (size_t i = smallest + 1; i < _line.size(); i++) {
+    Point<T> startP(_line[i - 1]);
+    Point<T> endP(_line[i]);
+
+    if (i > 1) {
+      totalDist += geo::dist(_line[i - 2], _line[i - 1]);
+    }
+
+    double curDist = distToSegment(startP, endP, p);
+
+    if (curDist < dist) {
+      dist = curDist;
+      smallest = i - 1;
+      smallestDist = totalDist;
+    }
+  }
+
+  if (totalLength > 0) {
+    smallestDist /= totalLength;
+  } else {
+    smallestDist = 0;
+  }
+
+  return std::pair<size_t, double>(smallest, smallestDist);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::pair<size_t, double> PolyLine<T>::nearestSegment(const Point<T>& p) const {
+  return nearestSegmentAfter(p, 0);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+LinePoint<T> PolyLine<T>::projectOn(const Point<T>& p) const {
+  return projectOnAfter(p, 0);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+LinePoint<T> PolyLine<T>::projectOnAfter(const Point<T>& p, size_t a) const {
+  assert(a < _line.size());
+  std::pair<size_t, double> bc = nearestSegmentAfter(p, a);
+
+  Point<T> ret = geo::projectOn(_line[bc.first], p, _line[bc.first + 1]);
+
+  if (getLength() > 0) {
+    bc.second += dist(_line[bc.first], ret) / getLength();
+  }
+
+  return LinePoint<T>(bc.first, bc.second, ret);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::simplify(double d) {
+  _line = geo::simplify(_line, d);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::smoothenOutliers(double d) {
+  if (_line.size() < 3) return;
+  for (size_t i = 1; i < _line.size() - 3; ++i) {
+    double ang = innerProd(_line[i], _line[i - 1], _line[i + 1]);
+
+    if (dist(_line[i], _line[i + 1]) < d || dist(_line[i], _line[i - 1]) < d) {
+      if (ang < 35) {
+        _line.erase(_line.begin() + i);
+      }
+    }
+  }
+}
+
+// _____________________________________________________________________________
+template <typename T>
+bool PolyLine<T>::equals(const PolyLine<T>& rhs) const {
+  // TODO: why 100? make global static or configurable or determine in some
+  //       way!
+  return equals(rhs, 100);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+bool PolyLine<T>::operator==(const PolyLine<T>& rhs) const {
+  // TODO: why 100? make global static or configurable or determine in some
+  //       way!
+  return equals(rhs, 100);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+bool PolyLine<T>::equals(const PolyLine<T>& rhs, double dmax) const {
+  // check if two lines are equal, THE DIRECTION DOES NOT MATTER HERE!!!!!
+
+  if (_line.size() == 2 && _line.size() == rhs.getLine().size()) {
+    // trivial case, straight line, implement directly
+    return (dist(_line[0], rhs.getLine()[0]) < dmax &&
+            dist(_line.back(), rhs.back()) < dmax) ||
+           (dist(_line[0], rhs.back()) < dmax &&
+            dist(_line.back(), rhs.getLine()[0]) < dmax);
+  } else {
+    return contains(rhs, dmax) && rhs.contains(*this, dmax);
+  }
+
+  return true;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+bool PolyLine<T>::contains(const PolyLine<T>& rhs, double dmax) const {
+  // check if two lines are equal. Line direction does not matter here.
+
+  for (size_t i = 0; i < rhs.getLine().size(); ++i) {
+    double d = dist(rhs.getLine()[i], getLine());
+    if (d > dmax) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::move(double vx, double vy) {
+  for (size_t i = 0; i < _line.size(); i++) {
+    _line[i].setX(_line[i].getX() + vx);
+    _line[i].setY(_line[i].getY() + vy);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename T>
+SharedSegments<T> PolyLine<T>::getSharedSegments(const PolyLine<T>& pl,
+                                                 double dmax) const {
+  /**
+   * Returns the segments this polyline share with pl
+   * atm, this is a very simple distance-based algorithm
+   */
+  double STEP_SIZE = 2;
+  double MAX_SKIPS = 4;
+  double MIN_SEG_LENGTH = 1;  // dmax / 2;  // make this configurable!
+
+  SharedSegments<T> ret;
+
+  if (distTo(pl) > dmax) return ret;
+
+  bool in = false, single = true;
+  double curDist = 0;
+  double curTotalSegDist = 0;
+  size_t skips;
+
+  LinePoint<T> curStartCand, curEndCand, curStartCandCmp, curEndCandCmp;
+
+  double comp = 0, curSegDist = 0;
+  double length = getLength(), plLength = pl.getLength();
+
+  for (size_t i = 1; i < _line.size(); ++i) {
+    const Point<T>& s = _line[i - 1];
+    const Point<T>& e = _line[i];
+
+    bool lastRound = false;
+
+    double totalDist = dist(s, e);
+    while (curSegDist <= totalDist) {
+      const Point<T>& curPointer = interpolate(s, e, curSegDist);
+
+      if (pl.distTo(curPointer) <= dmax) {
+        LinePoint<T> curCmpPointer = pl.projectOn(curPointer);
+        LinePoint<T> curBackProjectedPointer = projectOn(curCmpPointer.p);
+        skips = 0;
+
+        if (in) {
+          curEndCand = curBackProjectedPointer;
+          curEndCandCmp = curCmpPointer;
+
+          single = false;
+
+          comp = fabs(curStartCand.totalPos * length -
+                      curEndCand.totalPos * length) /
+                 fabs(curStartCandCmp.totalPos * plLength -
+                      curEndCandCmp.totalPos * plLength);
+        } else {
+          in = true;
+          curStartCand = curBackProjectedPointer;
+          curStartCandCmp = curCmpPointer;
+        }
+      } else {
+        if (in) {
+          skips++;
+          if (skips > MAX_SKIPS) {  // TODO: make configurable
+            if (comp > 0.8 && comp < 1.2 && !single &&
+                (fabs(curStartCand.totalPos * length -
+                      curEndCand.totalPos * length) > MIN_SEG_LENGTH &&
+                 fabs(curStartCandCmp.totalPos * plLength -
+                      curEndCandCmp.totalPos * plLength) > MIN_SEG_LENGTH)) {
+              ret.segments.push_back(
+                  SharedSegment<T>(std::pair<LinePoint<T>, LinePoint<T>>(
+                                       curStartCand, curStartCandCmp),
+                                   std::pair<LinePoint<T>, LinePoint<T>>(
+                                       curEndCand, curEndCandCmp)));
+
+              // TODO: only return the FIRST one, make this configuralbe
+              return ret;
+            }
+
+            in = false;
+            single = true;
+          }
+        }
+      }
+
+      if (curSegDist + STEP_SIZE > totalDist && !lastRound) {
+        lastRound = true;
+        double finalStep = totalDist - curSegDist - 0.0005;
+        curSegDist += finalStep;
+        curDist += finalStep;
+      } else {
+        curSegDist += STEP_SIZE;
+        curDist += STEP_SIZE;
+      }
+    }
+
+    curSegDist = curSegDist - totalDist;
+    curTotalSegDist += totalDist;
+  }
+
+  if (comp > 0.8 && comp < 1.2 && in && !single &&
+      (fabs(curStartCand.totalPos * length - curEndCand.totalPos * length) >
+           MIN_SEG_LENGTH &&
+       fabs(curStartCandCmp.totalPos * plLength -
+            curEndCandCmp.totalPos * plLength) > MIN_SEG_LENGTH)) {
+    ret.segments.push_back(SharedSegment<T>(
+        std::pair<LinePoint<T>, LinePoint<T>>(curStartCand, curStartCandCmp),
+        std::pair<LinePoint<T>, LinePoint<T>>(curEndCand, curEndCandCmp)));
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::set<LinePoint<T>, LinePointCmp<T>> PolyLine<T>::getIntersections(
+    const PolyLine<T>& g) const {
+  std::set<LinePoint<T>, LinePointCmp<T>> ret;
+
+  for (size_t i = 1; i < g.getLine().size(); ++i) {
+    // for each line segment, check if it intersects with a line segment in g
+    const std::set<LinePoint<T>, LinePointCmp<T>> a =
+        getIntersections(g, i - 1, i);
+    ret.insert(a.begin(), a.end());
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::set<LinePoint<T>, LinePointCmp<T>> PolyLine<T>::getIntersections(
+    const PolyLine<T>& p, size_t a, size_t b) const {
+  std::set<LinePoint<T>, LinePointCmp<T>> ret;
+
+  if (dist(p.getLine()[a], p.getLine()[b]) == 0) {
+    // we cannot intersect with a point
+    return ret;
+  }
+
+  for (size_t i = 1; i < _line.size(); ++i) {
+    if (intersects(_line[i - 1], _line[i], p.getLine()[a], p.getLine()[b])) {
+      Point<T> isect =
+          intersection(_line[i - 1], _line[i], p.getLine()[a], p.getLine()[b]);
+      ret.insert(p.projectOn(isect));
+    }
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename T>
+PolyLine<T> PolyLine<T>::getOrthoLineAtDist(double d, double length) const {
+  Point<T> avgP = getPointAtDist(d).p;
+
+  double angle = angBetween(getPointAtDist(d - 5).p, getPointAtDist(d + 5).p);
+
+  double angleX1 = avgP.getX() + cos(angle + M_PI / 2) * length / 2;
+  double angleY1 = avgP.getY() + sin(angle + M_PI / 2) * length / 2;
+
+  double angleX2 = avgP.getX() + cos(angle + M_PI / 2) * -length / 2;
+  double angleY2 = avgP.getY() + sin(angle + M_PI / 2) * -length / 2;
+
+  return PolyLine(Point<T>(angleX1, angleY1), Point<T>(angleX2, angleY2));
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::empty() {
+  _line.empty();
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::pair<double, double> PolyLine<T>::getSlopeBetween(double ad,
+                                                       double bd) const {
+  LinePoint<T> a = getPointAt(ad);
+  LinePoint<T> b = getPointAt(bd);
+
+  double d = dist(a.p, b.p);
+
+  double dx = (b.p.getX() - a.p.getX()) / d;
+  double dy = (b.p.getY() - a.p.getY()) / d;
+
+  return std::pair<double, double>(dx, dy);
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::pair<double, double> PolyLine<T>::getSlopeBetweenDists(double ad,
+                                                            double bd) const {
+  return getSlopeBetween(ad / getLength(), bd / getLength());
+}
+
+// _____________________________________________________________________________
+template <typename T>
+std::string PolyLine<T>::getWKT() const {
+  std::stringstream ss;
+  ss << std::setprecision(12) << geo::getWKT(_line);
+
+  return ss.str();
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::fixTopology(double maxl) {
+  double distA = 0;
+
+  for (size_t i = 1; i < _line.size() - 1; i++) {
+    double distB =
+        distA + dist(_line[i - 1], _line[i]) + dist(_line[i], _line[i + 1]);
+    for (size_t j = i + 2; j < _line.size(); j++) {
+      if (intersects(_line[i - 1], _line[i], _line[j - 1], _line[j])) {
+        Point<T> p =
+            intersection(_line[i - 1], _line[i], _line[j - 1], _line[j]);
+
+        double posA = dist(_line[i - 1], p) + distA;
+        double posB = dist(_line[j - 1], p) + distB;
+
+        if (fabs(posA - posB) < maxl) {
+          _line[i] = p;
+          _line.erase(_line.begin() + i + 1, _line.begin() + j);
+        }
+      }
+
+      distB += dist(_line[j - 1], _line[j]);
+    }
+    distA += dist(_line[i - 1], _line[i]);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void PolyLine<T>::applyChaikinSmooth(size_t depth) {
+  for (size_t i = 0; i < depth; i++) {
+    Line<T> smooth;
+
+    smooth.push_back(_line.front());
+
+    for (size_t i = 1; i < _line.size(); i++) {
+      Point<T> pA = _line[i - 1];
+      Point<T> pB = _line[i];
+
+      smooth.push_back(
+          Point<T>(0.75 * pA.getX() + 0.25 * pB.getX(),
+                   0.75 * pA.getY() + 0.25 * pB.getY()));
+      smooth.push_back(
+          Point<T>(0.25 * pA.getX() + 0.75 * pB.getX(),
+                   0.25 * pA.getY() + 0.75 * pB.getY()));
+    }
+
+    smooth.push_back(_line.back());
+    _line = smooth;
+  }
+}
+
+// _____________________________________________________________________________
+template <typename T>
+const Point<T>& PolyLine<T>::front() const {
+  return _line.front();
+}
+
+// _____________________________________________________________________________
+template <typename T>
+const Point<T>& PolyLine<T>::back() const {
+  return _line.back();
+}

src/util/geo/Polygon.h

@@ -0,0 +1,41 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Author: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_POLYGON_H_
+#define UTIL_GEO_POLYGON_H_
+
+#include <vector>
+#include "./Box.h"
+#include "./Line.h"
+#include "./Point.h"
+
+namespace util {
+namespace geo {
+
+template <typename T>
+class Polygon {
+ public:
+  Polygon() {}
+
+  Polygon(const Line<T>& l) : _outer(l) {}
+  Polygon(const Box<T>& b)
+      : _outer({b.getLowerLeft(),
+                Point<T>(b.getUpperRight().getX(), b.getLowerLeft().getY()),
+                b.getUpperRight(),
+                Point<T>(b.getLowerLeft().getX(), b.getUpperRight().getY())}) {}
+
+  const Line<T>& getOuter() const { return _outer; }
+  Line<T>& getOuter() { return _outer; }
+
+ private:
+  Line<T> _outer;
+};
+
+template <typename T>
+using MultiPolygon = std::vector<Polygon<T>>;
+
+}  // namespace geo
+}  // namespace util
+
+#endif  // UTIL_GEO_LINE_H_

src/util/geo/output/GeoGraphJsonOutput.h

@@ -0,0 +1,35 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_OUTPUT_GEOGRAPHJSONOUTPUT_H_
+#define UTIL_GEO_OUTPUT_GEOGRAPHJSONOUTPUT_H_
+
+#include <ostream>
+#include <string>
+#include "util/String.h"
+#include "util/geo/output/GeoJsonOutput.h"
+#include "util/graph/Graph.h"
+
+namespace util {
+namespace geo {
+namespace output {
+
+class GeoGraphJsonOutput {
+ public:
+  inline GeoGraphJsonOutput(){};
+  template <typename N, typename E>
+  void print(const util::graph::Graph<N, E>& outG, std::ostream& str);
+
+ private:
+  template <typename T>
+  Line<T> createLine(const util::geo::Point<T>& a,
+                     const util::geo::Point<T>& b);
+};
+
+#include "util/geo/output/GeoGraphJsonOutput.tpp"
+}
+}
+}
+
+#endif  // UTIL_GEO_OUTPUT_GEOGRAPHJSONOUTPUT_H_

src/util/geo/output/GeoGraphJsonOutput.tpp

@@ -0,0 +1,63 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename T>
+Line<T> GeoGraphJsonOutput::createLine(const util::geo::Point<T>& a,
+                                       const util::geo::Point<T>& b) {
+  Line<T> ret;
+  ret.push_back(a);
+  ret.push_back(b);
+  return ret;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void GeoGraphJsonOutput::print(const util::graph::Graph<N, E>& outG,
+                               std::ostream& str) {
+  GeoJsonOutput _out(str);
+
+  // first pass, nodes
+  for (util::graph::Node<N, E>* n : outG.getNds()) {
+    if (!n->pl().getGeom()) continue;
+
+    json::Dict props{{"id", util::toString(n)},
+                     {"deg", util::toString(n->getDeg())},
+                     {"deg_out", util::toString(n->getOutDeg())},
+                     {"deg_in", util::toString(n->getInDeg())}};
+
+    auto addProps = n->pl().getAttrs();
+    props.insert(addProps.begin(), addProps.end());
+
+    _out.print(*n->pl().getGeom(), props);
+  }
+
+  // second pass, edges
+  for (graph::Node<N, E>* n : outG.getNds()) {
+    for (graph::Edge<N, E>* e : n->getAdjListOut()) {
+      // to avoid double output for undirected graphs
+      if (e->getFrom() != n) continue;
+      json::Dict props{{"from", util::toString(e->getFrom())},
+                       {"to", util::toString(e->getTo())},
+                       {"id", util::toString(e)}};
+
+      auto addProps = e->pl().getAttrs();
+      props.insert(addProps.begin(), addProps.end());
+
+      if (!e->pl().getGeom() || !e->pl().getGeom()->size()) {
+        if (e->getFrom()->pl().getGeom()) {
+          auto a = *e->getFrom()->pl().getGeom();
+          if (e->getTo()->pl().getGeom()) {
+            auto b = *e->getTo()->pl().getGeom();
+            _out.print(createLine(a, b), props);
+          }
+        }
+      } else {
+        _out.print(*e->pl().getGeom(), props);
+      }
+    }
+  }
+
+  _out.flush();
+}

src/util/geo/output/GeoJsonOutput.cpp

@@ -0,0 +1,34 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+//
+#include "util/geo/output/GeoJsonOutput.h"
+
+using namespace util;
+using namespace geo;
+using namespace output;
+
+// _____________________________________________________________________________
+GeoJsonOutput::GeoJsonOutput(std::ostream& str) : _wr(&str, 10, true) {
+  _wr.obj();
+  _wr.keyVal("type", "FeatureCollection");
+  _wr.key("features");
+  _wr.arr();
+}
+
+// _____________________________________________________________________________
+GeoJsonOutput::GeoJsonOutput(std::ostream& str, json::Val attrs)
+    : _wr(&str, 10, true) {
+  _wr.obj();
+  _wr.keyVal("type", "FeatureCollection");
+  _wr.key("properties");
+  _wr.val(attrs);
+  _wr.key("features");
+  _wr.arr();
+}
+
+// _____________________________________________________________________________
+GeoJsonOutput::~GeoJsonOutput() { flush(); }
+
+// _____________________________________________________________________________
+void GeoJsonOutput::flush() { _wr.closeAll(); }

src/util/geo/output/GeoJsonOutput.h

@@ -0,0 +1,40 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GEO_OUTPUT_GEOJSONOUTPUT_H_
+#define UTIL_GEO_OUTPUT_GEOJSONOUTPUT_H_
+
+#include <ostream>
+#include <string>
+#include <map>
+#include "util/String.h"
+#include "util/geo/Geo.h"
+#include "util/json/Writer.h"
+
+namespace util {
+namespace geo {
+namespace output {
+
+class GeoJsonOutput {
+ public:
+  GeoJsonOutput(std::ostream& str);
+  GeoJsonOutput(std::ostream& str, json::Val attrs);
+  ~GeoJsonOutput();
+  template <typename T>
+  void print(const Point<T>& p, json::Val attrs);
+  template <typename T>
+  void print(const Line<T>& l, json::Val attrs);
+  void flush();
+
+ private:
+  json::Writer _wr;
+};
+
+#include "util/geo/output/GeoJsonOutput.tpp"
+
+}
+}
+}
+
+#endif  // UTIL_GEO_OUTPUT_GEOJSONOUTPUT_H_

src/util/geo/output/GeoJsonOutput.tpp

@@ -0,0 +1,48 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename T>
+void GeoJsonOutput::print(const Point<T>& p, json::Val attrs) {
+  _wr.obj();
+  _wr.keyVal("type", "Feature");
+
+  _wr.key("geometry");
+  _wr.obj();
+  _wr.keyVal("type", "Point");
+  _wr.key("coordinates");
+  _wr.arr();
+  _wr.val(p.getX());
+  _wr.val(p.getY());
+  _wr.close();
+  _wr.close();
+  _wr.key("properties");
+  _wr.val(attrs);
+  _wr.close();
+}
+
+// _____________________________________________________________________________
+template <typename T>
+void GeoJsonOutput::print(const Line<T>& line, json::Val attrs) {
+  if (!line.size()) return;
+  _wr.obj();
+  _wr.keyVal("type", "Feature");
+
+  _wr.key("geometry");
+  _wr.obj();
+  _wr.keyVal("type", "LineString");
+  _wr.key("coordinates");
+  _wr.arr();
+  for (auto p : line) {
+    _wr.arr();
+    _wr.val(p.getX());
+    _wr.val(p.getY());
+    _wr.close();
+  }
+  _wr.close();
+  _wr.close();
+  _wr.key("properties");
+  _wr.val(attrs);
+  _wr.close();
+}

src/util/graph/Algorithm.h

@@ -0,0 +1,33 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_ALGORITHM_H_
+#define UTIL_GRAPH_ALGORITHM_H_
+
+#include <stack>
+#include "util/graph/Edge.h"
+#include "util/graph/UndirGraph.h"
+#include "util/graph/Node.h"
+
+namespace util {
+namespace graph {
+
+using util::graph::Graph;
+using util::graph::Node;
+using util::graph::Edge;
+
+// collection of general graph algorithms
+class Algorithm {
+ public:
+  template <typename N, typename E>
+  static std::vector<std::set<Node<N, E>*> > connectedComponents(
+      const UndirGraph<N, E>& g);
+};
+
+#include "util/graph/Algorithm.tpp"
+
+}
+}
+
+#endif  // UTIL_GRAPH_ALGORITHM_H_

src/util/graph/Algorithm.tpp

@@ -0,0 +1,32 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+std::vector<std::set<Node<N, E>*> > Algorithm::connectedComponents(
+    const UndirGraph<N, E>& g) {
+  std::vector<std::set<Node<N, E>*>> ret;
+  std::set<Node<N, E>*> visited;
+
+  for (auto* n : g.getNds()) {
+    if (!visited.count(n)) {
+      ret.resize(ret.size() + 1);
+      std::stack<Node<N, E>*> q;
+      q.push(n);
+      while (!q.empty()) {
+        Node<N, E>* cur = q.top();
+        q.pop();
+
+        ret.back().insert(cur);
+        visited.insert(cur);
+
+        for (auto* e : cur->getAdjList()) {
+          if (!visited.count(e->getOtherNd(cur))) q.push(e->getOtherNd(cur));
+        }
+      }
+    }
+  }
+
+  return ret;
+}

src/util/graph/Dijkstra.cpp

@@ -0,0 +1,7 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include "util/graph/Dijkstra.h"
+
+size_t util::graph::Dijkstra::ITERS = 0;

src/util/graph/Dijkstra.h

@@ -0,0 +1,113 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_DIJKSTRA_H_
+#define UTIL_GRAPH_DIJKSTRA_H_
+
+#include <limits>
+#include <list>
+#include <queue>
+#include <set>
+#include <set>
+#include <unordered_map>
+#include "util/graph/Edge.h"
+#include "util/graph/Graph.h"
+#include "util/graph/Node.h"
+#include "util/graph/ShortestPath.h"
+
+namespace util {
+namespace graph {
+
+using util::graph::Graph;
+using util::graph::Node;
+using util::graph::Edge;
+
+// dijkstras algorithm for util graph
+class Dijkstra : public ShortestPath<Dijkstra> {
+ public:
+  template <typename N, typename E, typename C>
+  struct RouteNode {
+    RouteNode() : n(0), parent(0), d(), h(), e(0) {}
+    RouteNode(Node<N, E>* n) : n(n), parent(0), d(), h(), e(0) {}
+    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d, Edge<N, E>* e)
+        : n(n), parent(parent), d(d), h(), e(e) {}
+    RouteNode(Node<N, E>* n, Node<N, E>* parent, C d, C h, Edge<N, E>* e)
+        : n(n), parent(parent), d(d), h(h), e(e) {}
+
+    Node<N, E>* n;
+    Node<N, E>* parent;
+
+    C d;
+    C h;
+
+    Edge<N, E>* e;
+
+    bool operator<(const RouteNode<N, E, C>& p) const {
+      return h > p.h || (h == p.h && d > p.d);
+    }
+  };
+
+  template <typename N, typename E, typename C>
+  using Settled = std::unordered_map<Node<N, E>*, RouteNode<N, E, C> >;
+
+  template <typename N, typename E, typename C>
+  using PQ = std::priority_queue<RouteNode<N, E, C> >;
+
+  template <typename N, typename E, typename C>
+  struct CostFunc : public ShortestPath::CostFunc<N, E, C> {
+    C operator()(const Edge<N, E>* from, const Node<N, E>* n,
+                 const Edge<N, E>* to) const {
+      UNUSED(from);
+      UNUSED(n);
+      UNUSED(to);
+      return C();
+    };
+  };
+
+  template <typename N, typename E, typename C>
+  struct HeurFunc : public ShortestPath::HeurFunc<N, E, C> {
+    C operator()(const Edge<N, E>* from,
+                 const std::set<Edge<N, E>*>& to) const {
+      UNUSED(from);
+      UNUSED(to);
+      return C();
+    };
+  };
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPathImpl(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const ShortestPath::CostFunc<N, E, C>& costFunc, const ShortestPath::HeurFunc<N, E, C>&,
+      std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Node<N, E>*, NList<N, E>*> resNode);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(const std::set<Node<N, E>*> from, const std::set<Node<N, E>*>& to,
+                            const ShortestPath::CostFunc<N, E, C>& costFunc,
+                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                            const ShortestPath::CostFunc<N, E, C>& costFunc,
+                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static void relax(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
+                    const ShortestPath::CostFunc<N, E, C>& costFunc,
+                    const ShortestPath::HeurFunc<N, E, C>& heurFunc, PQ<N, E, C>& pq);
+
+  template <typename N, typename E, typename C>
+  static void buildPath(Node<N, E>* curN, Settled<N, E, C>& settled,
+                        NList<N, E>* resNodes, EList<N, E>* resEdges);
+
+  static size_t ITERS;
+};
+
+#include "util/graph/Dijkstra.tpp"
+}
+}
+
+#endif  // UTIL_GRAPH_DIJKSTRA_H_

src/util/graph/Dijkstra.tpp

@@ -0,0 +1,175 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C Dijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                             const ShortestPath::CostFunc<N, E, C>& costFunc,
+                             const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                             EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  if (from->getOutDeg() == 0) return costFunc.inf();
+
+  Settled<N, E, C> settled;
+  PQ<N, E, C> pq;
+  bool found = false;
+
+  pq.emplace(from);
+  RouteNode<N, E, C> cur;
+
+  while (!pq.empty()) {
+    Dijkstra::ITERS++;
+
+    if (settled.find(pq.top().n) != settled.end()) {
+      pq.pop();
+      continue;
+    }
+
+    cur = pq.top();
+    pq.pop();
+
+    settled[cur.n] = cur;
+
+    if (to.find(cur.n) != to.end()) {
+      found = true;
+      break;
+    }
+
+    relax(cur, to, costFunc, heurFunc, pq);
+  }
+
+  if (!found) return costFunc.inf();
+
+  buildPath(cur.n, settled, resNodes, resEdges);
+
+  return cur.d;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C Dijkstra::shortestPathImpl(const std::set<Node<N, E>*> from,
+                             const std::set<Node<N, E>*>& to,
+                             const ShortestPath::CostFunc<N, E, C>& costFunc,
+                             const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                             EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  Settled<N, E, C> settled;
+  PQ<N, E, C> pq;
+  bool found = false;
+
+  // put all nodes in from onto PQ
+  for (auto n : from) pq.emplace(n);
+  RouteNode<N, E, C> cur;
+
+  while (!pq.empty()) {
+    Dijkstra::ITERS++;
+
+    if (settled.find(pq.top().n) != settled.end()) {
+      pq.pop();
+      continue;
+    }
+
+    cur = pq.top();
+    pq.pop();
+
+    settled[cur.n] = cur;
+
+    if (to.find(cur.n) != to.end()) {
+      found = true;
+      break;
+    }
+
+    relax(cur, to, costFunc, heurFunc, pq);
+  }
+
+  if (!found) return costFunc.inf();
+
+  buildPath(cur.n, settled, resNodes, resEdges);
+
+  return cur.d;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+std::unordered_map<Node<N, E>*, C> Dijkstra::shortestPathImpl(
+    Node<N, E>* from, const std::set<Node<N, E>*>& to,
+    const ShortestPath::CostFunc<N, E, C>& costFunc,
+    const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+    std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
+    std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
+  std::unordered_map<Node<N, E>*, C> costs;
+  if (to.size() == 0) return costs;
+  // init costs with inf
+  for (auto n : to) costs[n] = costFunc.inf();
+
+  if (from->getOutDeg() == 0) return costs;
+
+  Settled<N, E, C> settled;
+  PQ<N, E, C> pq;
+
+  size_t found = 0;
+
+  pq.emplace(from);
+  RouteNode<N, E, C> cur;
+
+  while (!pq.empty()) {
+    Dijkstra::ITERS++;
+
+    if (settled.find(pq.top().n) != settled.end()) {
+      pq.pop();
+      continue;
+    }
+
+    cur = pq.top();
+    pq.pop();
+
+    settled[cur.n] = cur;
+
+    if (to.find(cur.n) != to.end()) {
+      found++;
+    }
+
+    if (found == to.size()) break;
+
+    relax(cur, to, costFunc, heurFunc, pq);
+  }
+
+  for (auto nto : to) {
+    if (!settled.count(nto)) continue;
+    Node<N, E>* curN = nto;
+    costs[nto] = settled[curN].d;
+
+    buildPath(nto, settled, resNodes[nto], resEdges[nto]);
+  }
+
+  return costs;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void Dijkstra::relax(RouteNode<N, E, C>& cur, const std::set<Node<N, E>*>& to,
+                     const ShortestPath::CostFunc<N, E, C>& costFunc,
+                     const ShortestPath::HeurFunc<N, E, C>& heurFunc, PQ<N, E, C>& pq) {
+  for (auto edge : cur.n->getAdjListOut()) {
+    C newC = costFunc(cur.n, edge, edge->getOtherNd(cur.n));
+    newC = cur.d + newC;
+    if (costFunc.inf() <= newC) continue;
+
+    const C& newH = newC + heurFunc(edge->getOtherNd(cur.n), to);
+
+    pq.emplace(edge->getOtherNd(cur.n), cur.n, newC, newH, &(*edge));
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void Dijkstra::buildPath(Node<N, E>* curN,
+                         Settled<N, E, C>& settled, NList<N, E>* resNodes,
+                         EList<N, E>* resEdges) {
+  while (true) {
+    const RouteNode<N, E, C>& curNode = settled[curN];
+    if (resNodes) resNodes->push_back(curNode.n);
+    if (!curNode.parent) break;
+    if (resEdges) resEdges->push_back(curNode.e);
+    curN = curNode.parent;
+  }
+}

src/util/graph/DirGraph.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 UTIL_GRAPH_DIRGRAPH_H_
+#define UTIL_GRAPH_DIRGRAPH_H_
+
+#include <set>
+#include <string>
+
+#include "util/graph/Graph.h"
+#include "util/graph/Edge.h"
+#include "util/graph/DirNode.h"
+
+namespace util {
+namespace graph {
+
+template <typename N, typename E>
+using UndirEdge = Edge<N, E>;
+
+template <typename N, typename E>
+class DirGraph : public Graph<N, E> {
+ public:
+  explicit DirGraph();
+
+  using Graph<N, E>::addEdg;
+
+  Node<N, E>* addNd();
+  Node<N, E>* addNd(DirNode<N, E>* n);
+  Node<N, E>* addNd(const N& pl);
+  Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to, const E& p);
+
+  Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b);
+
+};
+
+#include "util/graph/DirGraph.tpp"
+}
+}
+
+#endif  // UTIL_GRAPH_DIRGRAPH_H_

src/util/graph/DirGraph.tpp

@@ -0,0 +1,59 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+DirGraph<N, E>::DirGraph() {}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* DirGraph<N, E>::addNd(const N& pl) {
+  return addNd(new DirNode<N, E>(pl));
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* DirGraph<N, E>::addNd() {
+  return addNd(new DirNode<N, E>());
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* DirGraph<N, E>::addNd(DirNode<N, E>* n) {
+  auto ins = Graph<N, E>::getNds()->insert(n);
+  return *ins.first;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Edge<N, E>* DirGraph<N, E>::addEdg(Node<N, E>* from, Node<N, E>* to,
+                                    const E& p) {
+  Edge<N, E>* e = Graph<N, E>::getEdg(from, to);
+  if (!e) {
+    e = new Edge<N, E>(from, to, p);
+    from->addEdge(e);
+    to->addEdge(e);
+  }
+  return e;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* DirGraph<N, E>::mergeNds(Node<N, E>* a, Node<N, E>* b) {
+  for (auto e : a->getAdjListOut()) {
+    if (e->getTo() != b) {
+      addEdg(b, e->getTo(), e->pl());
+    }
+  }
+
+  for (auto e : a->getAdjListIn()) {
+    if (e->getFrom() != b) {
+      addEdg(e->getFrom(), b, e->pl());
+    }
+  }
+
+  DirGraph<N, E>::delNd(a);
+
+  return b;
+}

src/util/graph/DirNode.h

@@ -0,0 +1,58 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_DIRNODE_H_
+#define UTIL_GRAPH_DIRNODE_H_
+
+#include <vector>
+#include <algorithm>
+#include "util/graph/Node.h"
+
+namespace util {
+namespace graph {
+
+// forward declaration of Edge
+
+template <typename N, typename E>
+class DirNode : public Node<N, E> {
+ public:
+  DirNode();
+  DirNode(const N& pl);
+  ~DirNode();
+
+  const std::vector<Edge<N, E>*>& getAdjList() const;
+  const std::vector<Edge<N, E>*>& getAdjListIn() const;
+  const std::vector<Edge<N, E>*>& getAdjListOut() const;
+
+  size_t getDeg() const;
+  size_t getInDeg() const;
+  size_t getOutDeg() const;
+
+  bool hasEdgeIn(const Edge<N, E>* e) const;
+  bool hasEdgeOut(const Edge<N, E>* e) const;
+  bool hasEdge(const Edge<N, E>* e) const;
+
+  // add edge to this node's adjacency lists
+  void addEdge(Edge<N, E>* e);
+
+  // remove edge from this node's adjacency lists
+  void removeEdge(Edge<N, E>* e);
+
+  N& pl();
+  const N& pl() const;
+
+ private:
+  std::vector<Edge<N, E>*> _adjListIn;
+  std::vector<Edge<N, E>*> _adjListOut;
+  N _pl;
+
+  bool adjInContains(const Edge<N, E>* e) const;
+  bool adjOutContains(const Edge<N, E>* e) const;
+};
+
+#include "util/graph/DirNode.tpp"
+
+}}
+
+#endif  // UTIL_GRAPH_DIRNODE_H_

src/util/graph/DirNode.tpp

@@ -0,0 +1,153 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+DirNode<N, E>::DirNode() : _pl() {}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+DirNode<N, E>::DirNode(const N& pl) : _pl(pl) {}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+DirNode<N, E>::~DirNode() {
+  // delete self edges
+  for (auto e = _adjListOut.begin(); e != _adjListOut.end();) {
+    Edge<N, E>* eP = *e;
+    if (eP->getTo() == this) {
+      _adjListIn.erase(std::find(_adjListIn.begin(), _adjListIn.end(), eP));
+      e = _adjListOut.erase(e);
+      delete eP;
+    } else {
+      e++;
+    }
+  }
+
+  for (auto e = _adjListOut.begin(); e != _adjListOut.end(); e++) {
+    Edge<N, E>* eP = *e;
+
+    if (eP->getTo() != this) {
+      eP->getTo()->removeEdge(eP);
+      delete eP;
+    }
+  }
+
+  for (auto e = _adjListIn.begin(); e != _adjListIn.end(); e++) {
+    Edge<N, E>* eP = *e;
+
+    if (eP->getFrom() != this) {
+      eP->getFrom()->removeEdge(eP);
+      delete eP;
+    }
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void DirNode<N, E>::addEdge(Edge<N, E>* e) {
+  if (e->getFrom() == this && !adjOutContains(e)) {
+    _adjListOut.reserve(_adjListOut.size() + 1);
+    _adjListOut.push_back(e);
+  }
+  if (e->getTo() == this && !adjInContains(e)) {
+    _adjListIn.reserve(_adjListIn.size() + 1);
+    _adjListIn.push_back(e);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void DirNode<N, E>::removeEdge(Edge<N, E>* e) {
+  if (e->getFrom() == this) {
+    auto p = std::find(_adjListOut.begin(), _adjListOut.end(), e);
+    if (p != _adjListOut.end()) _adjListOut.erase(p);
+  }
+  if (e->getTo() == this) {
+    auto p = std::find(_adjListIn.begin(), _adjListIn.end(), e);
+    if (p != _adjListIn.end()) _adjListIn.erase(p);
+  }
+}
+//
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool DirNode<N, E>::hasEdgeIn(const Edge<N, E>* e) const {
+  return e->getTo() == this;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool DirNode<N, E>::hasEdgeOut(const Edge<N, E>* e) const {
+  return e->getFrom() == this;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool DirNode<N, E>::hasEdge(const Edge<N, E>* e) const {
+  return hasEdgeOut(e) || hasEdgeIn(e);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::vector<Edge<N, E>*>& DirNode<N, E>::getAdjList() const {
+  return _adjListOut;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::vector<Edge<N, E>*>& DirNode<N, E>::getAdjListOut() const {
+  return _adjListOut;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::vector<Edge<N, E>*>& DirNode<N, E>::getAdjListIn() const {
+  return _adjListIn;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+size_t DirNode<N, E>::getDeg() const {
+  return _adjListOut.size();
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+size_t DirNode<N, E>::getInDeg() const {
+  return _adjListIn.size();
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+size_t DirNode<N, E>::getOutDeg() const {
+  return _adjListOut.size();
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+N& DirNode<N, E>::pl() {
+  return _pl;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const N& DirNode<N, E>::pl() const {
+  return _pl;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool DirNode<N, E>::adjInContains(const Edge<N, E>* e) const {
+  for (size_t i = 0; i < _adjListIn.size(); i++)
+    if (_adjListIn[i] == e) return true;
+  return false;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool DirNode<N, E>::adjOutContains(const Edge<N, E>* e) const {
+  for (size_t i = 0; i < _adjListOut.size(); i++)
+    if (_adjListOut[i] == e) return true;
+  return false;
+}

src/util/graph/EDijkstra.cpp

@@ -0,0 +1,7 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include "util/graph/EDijkstra.h"
+
+size_t util::graph::EDijkstra::ITERS = 0;

src/util/graph/EDijkstra.h

@@ -0,0 +1,139 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_EDIJKSTRA_H_
+#define UTIL_GRAPH_EDIJKSTRA_H_
+
+#include <limits>
+#include <list>
+#include <queue>
+#include <set>
+#include <unordered_map>
+#include "util/graph/Edge.h"
+#include "util/graph/Graph.h"
+#include "util/graph/Node.h"
+#include "util/graph/ShortestPath.h"
+
+namespace util {
+namespace graph {
+
+using util::graph::Graph;
+using util::graph::Node;
+using util::graph::Edge;
+
+// edge-based dijkstra - settles edges instead of nodes
+class EDijkstra : public ShortestPath<EDijkstra> {
+ public:
+  template <typename N, typename E, typename C>
+  struct RouteEdge {
+    RouteEdge() : e(0), parent(0), d(), h(), n(0) {}
+    RouteEdge(Edge<N, E>* e) : e(e), parent(0), d(), h(), n(0) {}
+    RouteEdge(Edge<N, E>* e, Edge<N, E>* parent, Node<N, E>* n, C d)
+        : e(e), parent(parent), d(d), h(), n(n) {}
+    RouteEdge(Edge<N, E>* e, Edge<N, E>* parent, Node<N, E>* n, C d, C h)
+        : e(e), parent(parent), d(d), h(h), n(n) {}
+
+    Edge<N, E>* e;
+    Edge<N, E>* parent;
+
+    C d;
+    C h;
+
+    Node<N, E>* n;
+
+    bool operator<(const RouteEdge<N, E, C>& p) const {
+      return h > p.h || (h == p.h && d > p.d);
+    }
+  };
+
+  template <typename N, typename E, typename C>
+  struct CostFunc : public ShortestPath::CostFunc<N, E, C> {
+    C operator()(const Node<N, E>* from, const Edge<N, E>* e,
+                 const Node<N, E>* to) const {
+      UNUSED(from);
+      UNUSED(e);
+      UNUSED(to);
+      return C();
+    };
+  };
+
+  template <typename N, typename E, typename C>
+  struct HeurFunc : public ShortestPath::HeurFunc<N, E, C> {
+    C operator()(const Node<N, E>* from,
+                 const std::set<Node<N, E>*>& to) const {
+      UNUSED(from);
+      UNUSED(to);
+      return C();
+    };
+  };
+
+  template <typename N, typename E, typename C>
+  using Settled = std::unordered_map<Edge<N, E>*, RouteEdge<N, E, C> >;
+
+  template <typename N, typename E, typename C>
+  using PQ = std::priority_queue<RouteEdge<N, E, C> >;
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(const std::set<Edge<N, E>*> from,
+                            const std::set<Edge<N, E>*>& to,
+                            const ShortestPath::CostFunc<N, E, C>& costFunc,
+                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                            const ShortestPath::CostFunc<N, E, C>& costFunc,
+                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
+                            const ShortestPath::CostFunc<N, E, C>& costFunc,
+                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static C shortestPathImpl(const std::set<Edge<N, E>*>& from,
+                            const std::set<Node<N, E>*>& to,
+                            const ShortestPath::CostFunc<N, E, C>& costFunc,
+                            const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                            EList<N, E>* resEdges, NList<N, E>* resNodes);
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
+      const std::set<Edge<N, E>*>& from,
+      const ShortestPath::CostFunc<N, E, C>& costFunc, bool rev);
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPathImpl(
+      Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
+      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes);
+
+  template <typename N, typename E, typename C>
+  static void buildPath(Edge<N, E>* curE, const Settled<N, E, C>& settled,
+                        NList<N, E>* resNodes, EList<N, E>* resEdges);
+
+  template <typename N, typename E, typename C>
+  static inline void relax(RouteEdge<N, E, C>& cur,
+                           const std::set<Edge<N, E>*>& to,
+                           const ShortestPath::CostFunc<N, E, C>& costFunc,
+                           const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                           PQ<N, E, C>& pq);
+
+  template <typename N, typename E, typename C>
+  static void relaxInv(RouteEdge<N, E, C>& cur,
+                      const ShortestPath::CostFunc<N, E, C>& costFunc,
+                      PQ<N, E, C>& pq);
+
+  static size_t ITERS;
+};
+
+#include "util/graph/EDijkstra.tpp"
+}
+}
+
+#endif  // UTIL_GRAPH_DIJKSTRA_H_

src/util/graph/EDijkstra.tpp

@@ -0,0 +1,258 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C EDijkstra::shortestPathImpl(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                              const ShortestPath::CostFunc<N, E, C>& costFunc,
+                              const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                              EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  std::set<Edge<N, E>*> frEs;
+  std::set<Edge<N, E>*> toEs;
+
+  frEs.insert(from->getAdjListOut().begin(), from->getAdjListOut().end());
+
+  for (auto n : to) {
+    toEs.insert(n->getAdjListIn().begin(), n->getAdjListIn().end());
+  }
+
+  C cost = shortestPathImpl(frEs, toEs, costFunc, heurFunc, resEdges, resNodes);
+
+  // the beginning node is not included in our edge based dijkstra
+  if (resNodes) resNodes->push_back(from);
+
+  return cost;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C EDijkstra::shortestPathImpl(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
+                              const ShortestPath::CostFunc<N, E, C>& costFunc,
+                              const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                              EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  std::set<Edge<N, E>*> frEs;
+  std::set<Edge<N, E>*> toEs;
+
+  frEs.insert(from);
+
+  for (auto n : to) {
+    toEs.insert(n->getAdjListIn().begin(), n->getAdjListIn().end());
+  }
+
+  C cost = shortestPathImpl(frEs, toEs, costFunc, heurFunc, resEdges, resNodes);
+
+  return cost;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+C EDijkstra::shortestPathImpl(const std::set<Edge<N, E>*> from,
+                              const std::set<Edge<N, E>*>& to,
+                              const ShortestPath::CostFunc<N, E, C>& costFunc,
+                              const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                              EList<N, E>* resEdges, NList<N, E>* resNodes) {
+  if (from.size() == 0 || to.size() == 0) return costFunc.inf();
+
+  Settled<N, E, C> settled;
+  PQ<N, E, C> pq;
+  bool found = false;
+
+  // at the beginning, put all edges on the priority queue,
+  // init them with their own cost
+  for (auto e : from) {
+    C c = costFunc(0, 0, e);
+    C h = heurFunc(e, to);
+    pq.emplace(e, (Edge<N, E>*)0, (Node<N, E>*)0, c, c + h);
+  }
+
+  RouteEdge<N, E, C> cur;
+
+  while (!pq.empty()) {
+    EDijkstra::ITERS++;
+
+    if (settled.find(pq.top().e) != settled.end()) {
+      pq.pop();
+      continue;
+    }
+
+    cur = pq.top();
+    pq.pop();
+
+    settled[cur.e] = cur;
+
+    if (to.find(cur.e) != to.end()) {
+      found = true;
+      break;
+    }
+
+    relax(cur, to, costFunc, heurFunc, pq);
+  }
+
+  if (!found) return costFunc.inf();
+
+  buildPath(cur.e, settled, resNodes, resEdges);
+
+  return cur.d;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
+    const std::set<Edge<N, E>*>& from, const ShortestPath::CostFunc<N, E, C>& costFunc,
+    bool rev) {
+  std::unordered_map<Edge<N, E>*, C> costs;
+
+  Settled<N, E, C> settled;
+  PQ<N, E, C> pq;
+
+  std::set<Edge<N, E>*> to;
+
+  for (auto e : from) {
+    pq.emplace(e, (Edge<N, E>*)0, (Node<N, E>*)0, costFunc(0, 0, e), C());
+  }
+
+  RouteEdge<N, E, C> cur;
+
+  while (!pq.empty()) {
+    EDijkstra::ITERS++;
+
+    if (settled.find(pq.top().e) != settled.end()) {
+      pq.pop();
+      continue;
+    }
+
+    cur = pq.top();
+    pq.pop();
+
+    settled[cur.e] = cur;
+
+    costs[cur.e] = cur.d;
+    buildPath(cur.e, settled, (NList<N, E>*)0, (EList<N, E>*)0);
+
+    if (rev)
+      relaxInv(cur, costFunc, pq);
+    else
+      relax(cur, to, costFunc, ZeroHeurFunc<N, E, C>(), pq);
+  }
+
+  return costs;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+std::unordered_map<Edge<N, E>*, C> EDijkstra::shortestPathImpl(
+    Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
+    const ShortestPath::CostFunc<N, E, C>& costFunc,
+    const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+    std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
+    std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes) {
+  std::unordered_map<Edge<N, E>*, C> costs;
+  if (to.size() == 0) return costs;
+
+  // init costs with inf
+  for (auto e : to) costs[e] = costFunc.inf();
+
+  Settled<N, E, C> settled;
+  PQ<N, E, C> pq;
+
+  size_t found = 0;
+
+  C c = costFunc(0, 0, from);
+  C h = heurFunc(from, to);
+  pq.emplace(from, (Edge<N, E>*)0, (Node<N, E>*)0, c, c + h);
+
+  RouteEdge<N, E, C> cur;
+
+  while (!pq.empty()) {
+    EDijkstra::ITERS++;
+
+    if (settled.find(pq.top().e) != settled.end()) {
+      pq.pop();
+      continue;
+    }
+
+    cur = pq.top();
+    pq.pop();
+
+    settled[cur.e] = cur;
+
+    if (to.find(cur.e) != to.end()) {
+      found++;
+      costs[cur.e] = cur.d;
+      buildPath(cur.e, settled, resNodes[cur.e], resEdges[cur.e]);
+    }
+
+    if (found == to.size()) return costs;
+
+    relax(cur, to, costFunc, heurFunc, pq);
+  }
+
+  return costs;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void EDijkstra::relaxInv(RouteEdge<N, E, C>& cur,
+                         const ShortestPath::CostFunc<N, E, C>& costFunc,
+                         PQ<N, E, C>& pq) {
+
+  // handling undirected graph makes no sense here
+
+  for (const auto edge : cur.e->getFrom()->getAdjListIn()) {
+    if (edge == cur.e) continue;
+    C newC = costFunc(edge, cur.e->getFrom(), cur.e);
+    newC = cur.d + newC;
+    if (costFunc.inf() <= newC) continue;
+
+    pq.emplace(edge, cur.e, cur.e->getFrom(), newC, C());
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void EDijkstra::relax(RouteEdge<N, E, C>& cur, const std::set<Edge<N, E>*>& to,
+                      const ShortestPath::CostFunc<N, E, C>& costFunc,
+                      const ShortestPath::HeurFunc<N, E, C>& heurFunc,
+                      PQ<N, E, C>& pq) {
+  if (cur.e->getFrom()->hasEdgeIn(cur.e)) {
+    // for undirected graphs
+    for (const auto edge : cur.e->getFrom()->getAdjListOut()) {
+      if (edge == cur.e) continue;
+      C newC = costFunc(cur.e, cur.e->getFrom(), edge);
+      newC = cur.d + newC;
+      if (costFunc.inf() <= newC) continue;
+
+      const C& h = heurFunc(edge, to);
+      const C& newH = newC + h;
+
+      pq.emplace(edge, cur.e, cur.e->getFrom(), newC, newH);
+    }
+  }
+
+  for (const auto edge : cur.e->getTo()->getAdjListOut()) {
+    if (edge == cur.e) continue;
+    C newC = costFunc(cur.e, cur.e->getTo(), edge);
+    newC = cur.d + newC;
+    if (costFunc.inf() <= newC) continue;
+
+    const C& h = heurFunc(edge, to);
+    const C& newH = newC + h;
+
+    pq.emplace(edge, cur.e, cur.e->getTo(), newC, newH);
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E, typename C>
+void EDijkstra::buildPath(Edge<N, E>* curE, const Settled<N, E, C>& settled,
+                          NList<N, E>* resNodes, EList<N, E>* resEdges) {
+  const RouteEdge<N, E, C>* curEdge = &settled.find(curE)->second;
+  if (resNodes) resNodes->push_back(curEdge->e->getOtherNd(curEdge->n));
+  while (true) {
+    if (resNodes && curEdge->n) resNodes->push_back(curEdge->n);
+    if (resEdges) resEdges->push_back(curEdge->e);
+    if (!curEdge->parent) break;
+    curEdge = &settled.find(curEdge->parent)->second;
+  }
+}

src/util/graph/Edge.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 UTIL_GRAPH_EDGE_H_
+#define UTIL_GRAPH_EDGE_H_
+
+#include <vector>
+#include "util/graph/Node.h"
+
+namespace util {
+namespace graph {
+
+template <typename N, typename E>
+class Edge {
+ public:
+  Edge(Node<N, E>* from, Node<N, E>* to, const E& pl);
+
+  Node<N, E>* getFrom() const;
+  Node<N, E>* getTo() const;
+
+  Node<N, E>* getOtherNd(const Node<N, E>* notNode) const;
+
+  void setFrom(Node<N, E>* from);
+  void setTo(Node<N, E>* to);
+
+  E& pl();
+  const E& pl() const;
+
+ private:
+  Node<N, E>* _from;
+  Node<N, E>* _to;
+  E _pl;
+};
+
+#include "util/graph/Edge.tpp"
+
+}}
+
+#endif  // UTIL_GRAPH_EDGE_H_
+

src/util/graph/Edge.tpp

@@ -0,0 +1,41 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Edge<N, E>::Edge(Node<N, E>* from, Node<N, E>* to, const E& pl)
+ : _from(from), _to(to), _pl(pl) {
+
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* Edge<N, E>::getFrom() const {
+  return _from;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* Edge<N, E>::getTo() const {
+  return _to;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* Edge<N, E>::getOtherNd(const Node<N, E>* notNode) const {
+  if (_to == notNode) return _from;
+  return _to;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+E& Edge<N, E>::pl() {
+  return _pl;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const E& Edge<N, E>::pl() const {
+  return _pl;
+}

src/util/graph/Graph.h

@@ -0,0 +1,48 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_GRAPH_H_
+#define UTIL_GRAPH_GRAPH_H_
+
+#include <set>
+#include <string>
+#include <iostream>
+#include <cassert>
+
+#include "util/graph/Edge.h"
+#include "util/graph/Node.h"
+
+namespace util {
+namespace graph {
+
+template <typename N, typename E>
+class Graph {
+ public:
+  virtual ~Graph();
+  virtual Node<N, E>* addNd() = 0;
+  virtual Node<N, E>* addNd(const N& pl) = 0;
+  Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to);
+  virtual Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to, const E& p) = 0;
+  Edge<N, E>* getEdg(Node<N, E>* from, Node<N, E>* to);
+  const Edge<N, E>* getEdg(Node<N, E>* from, Node<N, E>* to) const;
+
+  virtual Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b) = 0;
+
+  const std::set<Node<N, E>*>& getNds() const;
+  std::set<Node<N, E>*>* getNds();
+
+  typename std::set<Node<N, E>*>::iterator delNd(Node<N, E>* n);
+  typename std::set<Node<N, E>*>::iterator delNd(
+      typename std::set<Node<N, E>*>::iterator i);
+  void delEdg(Node<N, E>* from, Node<N, E>* to);
+
+ private:
+  std::set<Node<N, E>*> _nodes;
+};
+
+#include "util/graph/Graph.tpp"
+}
+}
+
+#endif  // UTIL_GRAPH_GRAPH_H_

src/util/graph/Graph.tpp

@@ -0,0 +1,76 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Graph<N, E>::~Graph() {
+  for (auto n : _nodes) delete n;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Edge<N, E>* Graph<N, E>::addEdg(Node<N, E>* from, Node<N, E>* to) {
+  return addEdg(from, to, E());
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::set<Node<N, E>*>& Graph<N, E>::getNds() const {
+  return _nodes;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+std::set<Node<N, E>*>* Graph<N, E>::getNds() {
+  return &_nodes;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+typename std::set<Node<N, E>*>::iterator Graph<N, E>::delNd(
+    Node<N, E>* n) {
+  return delNd(_nodes.find(n));
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+typename std::set<Node<N, E>*>::iterator Graph<N, E>::delNd(
+    typename std::set<Node<N, E>*>::iterator i) {
+  delete *i;
+  return _nodes.erase(i);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void Graph<N, E>::delEdg(Node<N, E>* from, Node<N, E>* to) {
+  Edge<N, E>* toDel = getEdg(from, to);
+  if (!toDel) return;
+
+  from->removeEdge(toDel);
+  to->removeEdge(toDel);
+
+  assert(!getEdg(from, to));
+
+  delete toDel;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Edge<N, E>* Graph<N, E>::getEdg(Node<N, E>* from, Node<N, E>* to) {
+  for (auto e : from->getAdjList()) {
+    if (e->getOtherNd(from) == to) return e;
+  }
+
+  return 0;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const Edge<N, E>* Graph<N, E>::getEdg(Node<N, E>* from, Node<N, E>* to) const {
+  for (auto e : from->getAdjList()) {
+    if (e->getOtherNd(from) == to) return e;
+  }
+
+  return 0;
+}

src/util/graph/Node.h

@@ -0,0 +1,47 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_NODE_H_
+#define UTIL_GRAPH_NODE_H_
+
+#include <vector>
+
+namespace util {
+namespace graph {
+
+// forward declaration of Edge
+template <typename N, typename E>
+class Edge;
+
+template <typename N, typename E>
+class Node {
+ public:
+  virtual const std::vector<Edge<N, E>*>& getAdjList() const = 0;
+  virtual const std::vector<Edge<N, E>*>& getAdjListOut() const = 0;
+  virtual const std::vector<Edge<N, E>*>& getAdjListIn() const = 0;
+
+  virtual size_t getDeg() const = 0;
+  virtual size_t getInDeg() const = 0;
+  virtual size_t getOutDeg() const = 0;
+
+  virtual bool hasEdgeIn(const Edge<N, E>* e) const = 0;
+  virtual bool hasEdgeOut(const Edge<N, E>* e) const = 0;
+  virtual bool hasEdge(const Edge<N, E>* e) const = 0;
+
+  // add edge to this node's adjacency lists
+  virtual void addEdge(Edge<N, E>* e) = 0;
+  virtual void removeEdge(Edge<N, E>* e) = 0;
+
+  virtual ~Node() = 0;
+
+  virtual N& pl() = 0;
+  virtual const N& pl() const = 0;
+};
+
+template <typename N, typename E>
+inline Node<N, E>::~Node() {}
+
+}}
+
+#endif  // UTIL_GRAPH_NODE_H_

src/util/graph/ShortestPath.h

@@ -0,0 +1,401 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_SHORTESTPATH_H_
+#define UTIL_GRAPH_SHORTESTPATH_H_
+
+#include <exception>
+#include <iostream>
+#include <limits>
+#include <list>
+#include <queue>
+#include <set>
+#include <unordered_map>
+#include "util/graph/Edge.h"
+#include "util/graph/Graph.h"
+#include "util/graph/Node.h"
+
+namespace util {
+namespace graph {
+
+using util::graph::Graph;
+using util::graph::Node;
+using util::graph::Edge;
+
+// shortest path base class
+template <class D>
+class ShortestPath {
+ public:
+  template <typename N, typename E>
+  using EList = std::vector<Edge<N, E>*>;
+
+  template <typename N, typename E>
+  using NList = std::vector<Node<N, E>*>;
+
+  template <typename N, typename E, typename C>
+  struct CostFunc {
+    virtual C operator()(const Node<N, E>* from, const Edge<N, E>* e,
+                         const Node<N, E>* to) const = 0;
+    virtual C operator()(const Edge<N, E>* from, const Node<N, E>* n,
+                         const Edge<N, E>* to) const = 0;
+    virtual C inf() const = 0;
+  };
+
+  template <typename N, typename E, typename C>
+  struct HeurFunc {
+    virtual C operator()(const Node<N, E>* a,
+                         const std::set<Node<N, E>*>& b) const = 0;
+    virtual C operator()(const Edge<N, E>* a,
+                         const std::set<Edge<N, E>*>& b) const = 0;
+  };
+
+  template <typename N, typename E, typename C>
+  struct ZeroHeurFunc : public HeurFunc<N, E, C> {
+    C operator()(const Node<N, E>* a, const std::set<Node<N, E>*>& b) const {
+      UNUSED(a);
+      UNUSED(b);
+      return C();
+    }
+    C operator()(const Edge<N, E>* a, const std::set<Edge<N, E>*>& b) const {
+      UNUSED(a);
+      UNUSED(b);
+      return C();
+    }
+  };
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        EList<N, E>* resEdges, NList<N, E>* resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges,
+                               resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(const std::set<Node<N, E>*> from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        EList<N, E>* resEdges, NList<N, E>* resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges,
+                               resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        EList<N, E>* resEdges, NList<N, E>* resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(),
+                               resEdges, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPath(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const CostFunc<N, E, C>& costFunc, const HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges,
+                               resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPath(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const CostFunc<N, E, C>& costFunc,
+      std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(),
+                               resEdges, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPath(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const CostFunc<N, E, C>& costFunc, const HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges) {
+    std::unordered_map<Node<N, E>*, NList<N, E>*> dummyRet;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges,
+                               dummyRet);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPath(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const CostFunc<N, E, C>& costFunc,
+      std::unordered_map<Node<N, E>*, EList<N, E>*> resEdges) {
+    std::unordered_map<Node<N, E>*, NList<N, E>*> dummyRet;
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(),
+                               resEdges, dummyRet);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPath(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const CostFunc<N, E, C>& costFunc,
+      std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
+    std::unordered_map<Node<N, E>*, EList<N, E>*> dummyRet;
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(),
+                               dummyRet, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Node<N, E>*, C> shortestPath(
+      Node<N, E>* from, const std::set<Node<N, E>*>& to,
+      const CostFunc<N, E, C>& costFunc, const HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Node<N, E>*, NList<N, E>*> resNodes) {
+    std::unordered_map<Node<N, E>*, EList<N, E>*> dummyRet;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, dummyRet,
+                               resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        EList<N, E>* resEdges, NList<N, E>* resNodes) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    return shortestPath(from, tos, costFunc, resEdges, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    EList<N, E>* el = 0;
+    NList<N, E>* nl = 0;
+    return shortestPath(from, tos, costFunc, el, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        NList<N, E>* resNodes) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    EList<N, E>* el = 0;
+    return shortestPath(from, tos, costFunc, el, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        EList<N, E>* resEdges) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    NList<N, E>* nl = 0;
+    return shortestPath(from, tos, costFunc, resEdges, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        NList<N, E>* resNodes) {
+    EList<N, E>* el = 0;
+    return shortestPath(from, to, costFunc, el, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        EList<N, E>* resEdges) {
+    NList<N, E>* nl = 0;
+    return shortestPath(from, to, costFunc, resEdges, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        EList<N, E>* resEdges, NList<N, E>* resNodes) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    return D::shortestPathImpl(from, tos, costFunc, heurFunc, resEdges,
+                               resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        NList<N, E>* resNodes) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    EList<N, E>* el = 0;
+    return D::shortestPathImpl(from, tos, costFunc, heurFunc, el, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        EList<N, E>* resEdges) {
+    if (to->getInDeg() == 0) return costFunc.inf();
+    std::set<Node<N, E>*> tos;
+    tos.insert(to);
+    NList<N, E>* nl = 0;
+    return D::shortestPathImpl(from, tos, costFunc, heurFunc, resEdges, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        NList<N, E>* resNodes) {
+    EList<N, E>* el = 0;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, el, resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Node<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc,
+                        EList<N, E>* resEdges) {
+    NList<N, E>* nl = 0;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPath(
+      Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
+      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges,
+      std::unordered_map<Edge<N, E>*, NList<N, E>*> resNodes) {
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges,
+                               resNodes);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPath(
+      Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
+      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const HeurFunc<N, E, C>& heurFunc,
+      std::unordered_map<Edge<N, E>*, EList<N, E>*> resEdges) {
+    std::unordered_map<Edge<N, E>*, NList<N, E>*> dummyRet;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, resEdges,
+                               dummyRet);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPath(
+      Edge<N, E>* from, const std::set<Edge<N, E>*>& to,
+      const ShortestPath::CostFunc<N, E, C>& costFunc,
+      const HeurFunc<N, E, C>& heurFunc) {
+    std::unordered_map<Edge<N, E>*, NList<N, E>*> dummyRet;
+    std::unordered_map<Edge<N, E>*, EList<N, E>*> dummyRetE;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, dummyRetE,
+                               dummyRet);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(const std::set<Edge<N, E>*>& from,
+                        const std::set<Edge<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc) {
+    NList<N, E>* nl = 0;
+    EList<N, E>* el = 0;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, el, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Edge<N, E>* from,
+                        Edge<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc ) {
+    NList<N, E>* nl = 0;
+    EList<N, E>* el = 0;
+    std::set<Edge<N, E>*> tos{to};
+    std::set<Edge<N, E>*> froms{from};
+    return D::shortestPathImpl(froms, tos, costFunc, ZeroHeurFunc<N, E, C>(), el, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(const std::set<Edge<N, E>*>& from,
+                        const std::set<Edge<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc, EList<N, E>* el) {
+    NList<N, E>* nl = 0;
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, el, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc, EList<N, E>* el,
+                        NList<N, E>* nl) {
+    return D::shortestPathImpl(from, to, costFunc, heurFunc, el, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Edge<N, E>* from, const std::set<Node<N, E>*>& to,
+                        const CostFunc<N, E, C>& costFunc,
+                        EList<N, E>* el,
+                        NList<N, E>* nl) {
+    return D::shortestPathImpl(from, to, costFunc, ZeroHeurFunc<N, E, C>(), el,
+                               nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Edge<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc,
+                        const HeurFunc<N, E, C>& heurFunc, EList<N, E>* el,
+                        NList<N, E>* nl) {
+    std::set<Node<N, E>*> tos{to};
+    return D::shortestPathImpl(from, tos, costFunc, heurFunc, el, nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static C shortestPath(Edge<N, E>* from, Node<N, E>* to,
+                        const CostFunc<N, E, C>& costFunc, EList<N, E>* el,
+                        NList<N, E>* nl) {
+    std::set<Node<N, E>*> tos{to};
+    return D::shortestPathImpl(from, tos, costFunc, ZeroHeurFunc<N, E, C>(), el,
+                               nl);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPath(
+      Edge<N, E>* from,
+      const ShortestPath::CostFunc<N, E, C>& costFunc) {
+    std::set<Edge<N, E>*> froms { from };
+    return D::shortestPathImpl(froms, costFunc, false);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPathRev(
+      Edge<N, E>* from,
+      const ShortestPath::CostFunc<N, E, C>& costFunc) {
+    std::set<Edge<N, E>*> froms { from };
+    return D::shortestPathImpl(froms, costFunc, true);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPath(
+      Node<N, E>* from,
+      const ShortestPath::CostFunc<N, E, C>& costFunc) {
+    std::set<Edge<N, E>*> froms;
+    froms.insert(from->getAdjListOut().begin(), from->getAdjListOut().end());
+    return D::shortestPathImpl(froms, costFunc, false);
+  }
+
+  template <typename N, typename E, typename C>
+  static std::unordered_map<Edge<N, E>*, C> shortestPathRev(
+      Node<N, E>* from,
+      const ShortestPath::CostFunc<N, E, C>& costFunc) {
+    std::set<Edge<N, E>*> froms;
+    froms.insert(from->getAdjListOut().begin(), from->getAdjListOut().end());
+    return D::shortestPathImpl(froms, costFunc, true);
+  }
+};
+}
+}
+
+#endif  // UTIL_GRAPH_SHORTESTPATH_H_

src/util/graph/ShortestPath.tpp

@@ -0,0 +1 @@
+

src/util/graph/UndirGraph.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 UTIL_GRAPH_UNDIRGRAPH_H_
+#define UTIL_GRAPH_UNDIRGRAPH_H_
+
+#include <set>
+#include <string>
+
+#include "util/graph/Graph.h"
+#include "util/graph/Edge.h"
+#include "util/graph/UndirNode.h"
+
+namespace util {
+namespace graph {
+
+template <typename N, typename E>
+using UndirEdge = Edge<N, E>;
+
+template <typename N, typename E>
+class UndirGraph : public Graph<N, E> {
+ public:
+  explicit UndirGraph();
+
+  using Graph<N, E>::addEdg;
+
+  Node<N, E>* addNd();
+  Node<N, E>* addNd(UndirNode<N, E>* n);
+  Node<N, E>* addNd(const N& pl);
+  Edge<N, E>* addEdg(Node<N, E>* from, Node<N, E>* to, const E& p);
+
+  Node<N, E>* mergeNds(Node<N, E>* a, Node<N, E>* b);
+
+};
+
+#include "util/graph/UndirGraph.tpp"
+}
+}
+
+#endif  // UTIL_GRAPH_UNDIRGRAPH_H_

src/util/graph/UndirGraph.tpp

@@ -0,0 +1,59 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+UndirGraph<N, E>::UndirGraph() {}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* UndirGraph<N, E>::addNd(const N& pl) {
+  return addNd(new UndirNode<N, E>(pl));
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* UndirGraph<N, E>::addNd() {
+  return addNd(new UndirNode<N, E>());
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* UndirGraph<N, E>::addNd(UndirNode<N, E>* n) {
+  auto ins = Graph<N, E>::getNds()->insert(n);
+  return *ins.first;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Edge<N, E>* UndirGraph<N, E>::addEdg(Node<N, E>* from, Node<N, E>* to,
+                                     const E& p) {
+  Edge<N, E>* e = Graph<N, E>::getEdg(from, to);
+  if (!e) {
+    e = new Edge<N, E>(from, to, p);
+    from->addEdge(e);
+    to->addEdge(e);
+  }
+  return e;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+Node<N, E>* UndirGraph<N, E>::mergeNds(Node<N, E>* a, Node<N, E>* b) {
+  for (auto e : a->getAdjListOut()) {
+    if (e->getTo() != b) {
+      addEdg(b, e->getTo(), e->pl());
+    }
+  }
+
+  for (auto e : a->getAdjListIn()) {
+    if (e->getFrom() != b) {
+      addEdg(e->getFrom(), b, e->pl());
+    }
+  }
+
+  UndirGraph<N, E>::delNd(a);
+
+  return b;
+}

src/util/graph/UndirNode.h

@@ -0,0 +1,54 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_GRAPH_UNDIRNODE_H_
+#define UTIL_GRAPH_UNDIRNODE_H_
+
+#include <vector>
+#include <algorithm>
+#include "util/graph/Node.h"
+
+namespace util {
+namespace graph {
+
+template <typename N, typename E>
+class UndirNode : public Node<N, E> {
+ public:
+  UndirNode();
+  UndirNode(const N& pl);
+  ~UndirNode();
+
+  const std::vector<Edge<N, E>*>& getAdjList() const;
+  const std::vector<Edge<N, E>*>& getAdjListIn() const;
+  const std::vector<Edge<N, E>*>& getAdjListOut() const;
+
+  size_t getDeg() const;
+  size_t getInDeg() const;
+  size_t getOutDeg() const;
+
+  bool hasEdgeIn(const Edge<N, E>* e) const;
+  bool hasEdgeOut(const Edge<N, E>* e) const;
+  bool hasEdge(const Edge<N, E>* e) const;
+
+  // add edge to this node's adjacency lists
+  void addEdge(Edge<N, E>* e);
+
+  // remove edge from this node's adjacency lists
+  void removeEdge(Edge<N, E>* e);
+
+  N& pl();
+  const N& pl() const;
+
+ private:
+  std::vector<Edge<N, E>*> _adjList;
+  N _pl;
+
+  bool adjContains(const Edge<N, E>* e) const;
+};
+
+#include "util/graph/UndirNode.tpp"
+
+}}
+
+#endif  // UTIL_GRAPH_UNDIRNODE_H_

src/util/graph/UndirNode.tpp

@@ -0,0 +1,130 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+UndirNode<N, E>::UndirNode() : _pl() {
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+UndirNode<N, E>::UndirNode(const N& pl) : _pl(pl) {
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+UndirNode<N, E>::~UndirNode() {
+  // delete self edges
+  for (auto e = _adjList.begin(); e != _adjList.end();) {
+    Edge<N, E>* eP = *e;
+    if (eP->getTo() == this && eP->getFrom() == this) {
+      e = _adjList.erase(e);
+      delete eP;
+    } else {
+      e++;
+    }
+  }
+
+  for (auto e = _adjList.begin(); e != _adjList.end(); e++) {
+    Edge<N, E>* eP = *e;
+
+    if (eP->getTo() != this) {
+      eP->getTo()->removeEdge(eP);
+    }
+
+    if (eP->getFrom() != this) {
+      eP->getFrom()->removeEdge(eP);
+    }
+
+    delete eP;
+  }
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool UndirNode<N, E>::hasEdgeIn(const Edge<N, E>* e) const {
+  return hasEdge(e);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool UndirNode<N, E>::hasEdgeOut(const Edge<N, E>* e) const {
+  return hasEdge(e);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool UndirNode<N, E>::hasEdge(const Edge<N, E>* e) const {
+  return e->getFrom() == this || e->getTo() == this;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+bool UndirNode<N, E>::adjContains(const Edge<N, E>* e) const {
+  for (size_t i = 0; i < _adjList.size(); i++) if (_adjList[i] == e) return true;
+  return false;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void UndirNode<N, E>::addEdge(Edge<N, E>* e) {
+  if (adjContains(e)) return;
+  _adjList.reserve(_adjList.size() + 1);
+  _adjList.push_back(e);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+void UndirNode<N, E>::removeEdge(Edge<N, E>* e) {
+  auto p = std::find(_adjList.begin(), _adjList.end(), e);
+  if (p != _adjList.end()) _adjList.erase(p);
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::vector<Edge<N, E>*>& UndirNode<N, E>::getAdjList() const {
+  return _adjList;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::vector<Edge<N, E>*>& UndirNode<N, E>::getAdjListOut() const {
+  return _adjList;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const std::vector<Edge<N, E>*>& UndirNode<N, E>::getAdjListIn() const {
+  return _adjList;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+size_t UndirNode<N, E>::getDeg() const {
+  return _adjList.size();
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+size_t UndirNode<N, E>::getInDeg() const {
+  return getDeg();
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+size_t UndirNode<N, E>::getOutDeg() const {
+  return getDeg();
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+N& UndirNode<N, E>::pl() {
+  return _pl;
+}
+
+// _____________________________________________________________________________
+template <typename N, typename E>
+const N& UndirNode<N, E>::pl() const {
+  return _pl;
+}

src/util/http/Server.cpp

@@ -0,0 +1,343 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef ZLIB_CONST
+#define ZLIB_CONST
+#endif
+
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <algorithm>
+#include <memory>
+#include <sstream>
+#include <stdexcept>
+#include <thread>
+#include <unordered_map>
+#ifdef ZLIB_FOUND
+#include <zlib.h>
+#endif
+#include <vector>
+#include "Server.h"
+#include "util/String.h"
+
+using util::http::Socket;
+using util::http::Queue;
+using util::http::Req;
+using util::http::HttpErr;
+using util::http::HttpServer;
+using util::http::HeaderState;
+
+// _____________________________________________________________________________
+Socket::Socket(int port) {
+  int y = 1;
+  _sock = socket(PF_INET, SOCK_STREAM, 0);
+  if (_sock < 0)
+    throw std::runtime_error(std::string("Could not create socket (") +
+                             std::strerror(errno) + ")");
+
+  struct sockaddr_in addr;
+
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons(port);
+  addr.sin_addr.s_addr = INADDR_ANY;
+  memset(&(addr.sin_zero), '\0', 8);
+
+  setsockopt(_sock, SOL_SOCKET, SO_REUSEADDR, &y, sizeof(y));
+
+  if (bind(_sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
+    throw std::runtime_error(std::string("Could not bind to port ") +
+                             std::to_string(port) + " (" +
+                             std::strerror(errno) + ")");
+  }
+}
+
+// _____________________________________________________________________________
+Socket::~Socket() { close(_sock); }
+
+// _____________________________________________________________________________
+int Socket::wait() {
+  if (listen(_sock, BLOG) < 0)
+    throw std::runtime_error(std::string("Cannot listen to socket (") +
+                             std::strerror(errno) + ")");
+  sockaddr_in cli_addr;
+  socklen_t clilen = sizeof(cli_addr);
+  int sock = accept(_sock, reinterpret_cast<sockaddr*>(&cli_addr), &clilen);
+  return sock;
+}
+
+// _____________________________________________________________________________
+void HttpServer::send(int sock, Answer* aw) {
+  std::string enc = "identity";
+  if (aw->gzip) aw->pl = compress(aw->pl, &enc);
+
+  aw->params["Content-Encoding"] = enc;
+  aw->params["Content-Length"] = std::to_string(aw->pl.size());
+
+  std::stringstream ss;
+  ss << "HTTP/1.1 " << aw->status << "\r\n";
+  for (const auto& kv : aw->params)
+    ss << kv.first << ": " << kv.second << "\r\n";
+  ss << "\r\n" << aw->pl;
+  std::string buff = ss.str();
+
+  size_t writes = 0;
+
+  while (writes != buff.size()) {
+    int64_t out = write(sock, buff.c_str() + writes, buff.size() - writes);
+    if (out < 0) {
+      if (errno == EWOULDBLOCK || errno == EAGAIN || errno == EINTR) continue;
+      throw std::runtime_error("Failed to write to socket");
+    }
+    writes += out;
+  }
+}
+
+// _____________________________________________________________________________
+void HttpServer::handle() {
+  int connection = -1;
+  while ((connection = _jobs.get()) != -1) {
+    Answer answ;
+
+    try {
+      Req req = getReq(connection);
+      answ = _handler->handle(req, connection);
+      answ.gzip = gzipSupport(req);
+    } catch (const HttpErr& err) {
+      answ = Answer(err.what(), err.what());
+    } catch (...) {
+      // catch everything to make sure the server continues running
+      answ = Answer("500 Internal Server Error", "500 Internal Server Error");
+    }
+
+    send(connection, &answ);
+    close(connection);
+  }
+}
+
+// _____________________________________________________________________________
+bool HttpServer::gzipSupport(const Req& req) {
+  bool accepts = false;
+  // decide according to
+  // http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+  for (const auto& kv : req.params) {
+    if (kv.first == "Accept-Encoding") {
+      for (const auto& encoding : split(kv.second, ',')) {
+        std::vector<std::string> parts = split(encoding, ';');
+        for (size_t i = 0; i < parts.size(); i++) {
+          parts[i] = trim(parts[i]);
+        }
+        if (parts[0] == "*" && ((parts.size() == 1) || parts[1] != "q=0"))
+          accepts = true;
+        if (parts[0] == "gzip") accepts = true;
+        if (parts.size() > 1 && parts[1] == "q=0") accepts = false;
+      }
+    }
+  }
+  return accepts;
+}
+
+// _____________________________________________________________________________
+Req HttpServer::getReq(int connection) {
+  char buf[BSIZE + 1];
+  size_t rcvd = 0;
+  int64_t curRcvd = 0;
+  HeaderState state = NONE;
+  Req ret;
+  char* tmp = 0;
+  char* tmp2 = 0;
+  char* brk = 0;
+
+  while ((curRcvd = read(connection, buf + rcvd, BSIZE - rcvd))) {
+    if (curRcvd < 0) {
+      if (errno == EAGAIN || errno == EINTR) continue;
+      throw HttpErr("500 Internal Server Error");
+    }
+
+    // parse request
+    for (int i = 0; i < curRcvd; i++) {
+      if (brk) break;
+      char* c = buf + rcvd + i;
+      switch (state) {
+        case NONE:
+          state = I_COM;
+          tmp = c;
+          continue;
+        case I_VER:
+          if (*c == '\n') {
+            *c = 0;
+            ret.ver = trim(tmp);
+            state = A_KEY;
+          }
+          continue;
+        case I_URL:
+          if (*c == ' ') {
+            *c = 0, ret.url = trim(tmp);
+            tmp = c + 1;
+            state = I_VER;
+          } else if (*c == '\n') {
+            *c = 0, ret.url = trim(tmp);
+            state = A_KEY;
+          }
+          continue;
+        case I_COM:
+          if (*c == ' ') {
+            *c = 0, ret.cmd = trim(tmp);
+            tmp = c + 1;
+            state = I_URL;
+          } else if (*c == '\n') {
+            *c = 0, ret.cmd = trim(tmp);
+            state = A_KEY;
+          }
+          continue;
+        case A_KEY:
+          if (*c == '\r') *c = ' ';
+          if (*c == '\n')
+            brk = c + 1;
+          else if (*c != ' ') {
+            state = I_KEY;
+            tmp = c;
+          }
+          continue;
+        case I_KEY:
+          if (*c == ':') {
+            *c = 0;
+            state = A_VAL;
+          }
+          continue;
+        case A_VAL:
+          if (*c != ' ') {
+            state = I_VAL;
+            tmp2 = c;
+          }
+          continue;
+        case I_VAL:
+          if (*c == '\r') *c = ' ';
+          if (*c == '\n') {
+            *c = 0;
+            ret.params[tmp] = trim(tmp2);
+            state = A_KEY;
+          }
+          continue;
+      }
+    }
+
+    rcvd += curRcvd;
+
+    // buffer is full
+    if (rcvd == BSIZE) throw HttpErr("431 Request Header Fields Too Large");
+    if (brk) break;
+  }
+
+  // POST payload
+  if (ret.cmd == "POST") {
+    size_t size = 0;
+    if (ret.params.count("Content-Length"))
+      size = atoi(ret.params["Content-Length"].c_str());
+    if (size) {
+      char* postBuf = new char[size + 1];
+      postBuf[size] = 0;
+      size_t rem = 0;
+
+      // copy existing to new buffer
+      if ((int)rcvd > brk - buf) {
+        rem = std::min(size, rcvd - (brk - buf));
+        memcpy(postBuf, brk, rem);
+      }
+
+      rcvd = 0;
+
+      if (rem < size) {
+        while ((curRcvd = read(connection, postBuf + rcvd + rem, size - rem))) {
+          if (curRcvd == -1 && (errno == EAGAIN || errno == EINTR)) continue;
+          if (curRcvd == -1) {
+            postBuf[rcvd + 1] = 0;
+            break;
+          }
+          rcvd += curRcvd;
+          if (rcvd == size - rem) break;
+        }
+      }
+
+      ret.payload = postBuf;
+      delete[] postBuf;
+    }
+  }
+
+  return ret;
+}
+
+// _____________________________________________________________________________
+std::string HttpServer::compress(const std::string& str, std::string* enc) {
+#ifdef ZLIB_FOUND
+  // do not compress small payloads
+  if (str.size() < 500) return str;
+
+  std::string ret;
+
+  // based on http://www.zlib.net/zlib_how.html
+  z_stream defStr;
+  defStr.zalloc = Z_NULL;
+  defStr.zfree = Z_NULL;
+  defStr.opaque = Z_NULL;
+  defStr.avail_in = 0;
+  defStr.next_in = Z_NULL;
+
+  // fail silently with no compression at all
+  if (deflateInit2(&defStr, Z_DEFAULT_COMPRESSION, Z_DEFLATED, 15 + 16, 8,
+                   Z_DEFAULT_STRATEGY) != Z_OK)
+    return str;
+
+  defStr.next_in = reinterpret_cast<z_const Bytef*>(str.c_str());
+  defStr.avail_in = static_cast<unsigned int>(str.size());
+
+  size_t cSize = 0;
+  do {
+    if (ret.size() < (cSize + BSIZE_C)) ret.resize(cSize + BSIZE_C);
+    defStr.avail_out = BSIZE_C;
+    defStr.next_out = reinterpret_cast<Bytef*>(&ret[0] + cSize);
+    deflate(&defStr, Z_FINISH);
+    cSize += BSIZE_C - defStr.avail_out;
+  } while (defStr.avail_out == 0);
+
+  deflateEnd(&defStr);
+  ret.resize(cSize);
+
+  if (ret.size() > str.size()) return str;
+  *enc = "gzip";
+  return ret;
+#else
+  return str;
+#endif
+}
+
+// _____________________________________________________________________________
+void HttpServer::run() {
+  Socket socket(_port);
+
+  std::vector<std::thread> thrds(_threads);
+  for (auto& thr : thrds) thr = std::thread(&HttpServer::handle, this);
+
+  while (1) _jobs.add(socket.wait());
+}
+
+// _____________________________________________________________________________
+void Queue::add(int c) {
+  if (c < 0) return;
+  {
+    std::unique_lock<std::mutex> lock(_mut);
+    _jobs.push(c);
+  }
+  _hasNew.notify_one();
+}
+
+// _____________________________________________________________________________
+int Queue::get() {
+  std::unique_lock<std::mutex> lock(_mut);
+  while (_jobs.empty()) _hasNew.wait(lock);
+  int next = _jobs.front();
+  _jobs.pop();
+  return next;
+}

src/util/http/Server.h

@@ -0,0 +1,139 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <condition_variable>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <mutex>
+#include <queue>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include <unistd.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#ifndef UTIL_HTTP_SERVER_H_
+#define UTIL_HTTP_SERVER_H_
+
+namespace util {
+namespace http {
+
+// socket backlog size
+const static size_t BLOG = 128;
+// socket read buffer size
+const static size_t BSIZE = 4 * 1024;
+// zlib compression buffer size
+const size_t BSIZE_C = 128 * 1024;
+
+// states for HTTP header parser
+enum HeaderState { NONE, I_COM, I_URL, I_VER, A_KEY, I_KEY, A_VAL, I_VAL };
+
+/*
+ * HTTP Error
+ */
+class HttpErr : public std::exception {
+ public:
+  HttpErr(std::string msg) : _msg(msg) {}
+  ~HttpErr() throw() {}
+
+  virtual const char* what() const throw() { return _msg.c_str(); }
+
+ private:
+  std::string _msg;
+};
+
+/*
+ * HTTP Request
+ */
+struct Req {
+  std::string cmd, url, ver, payload;
+  std::unordered_map<std::string, std::string> params;
+};
+
+/*
+ * HTTP Answer
+ */
+struct Answer {
+  Answer() : status(""), pl(""), gzip(false) {}
+  Answer(const std::string& status, const std::string& pl)
+      : status(status), pl(pl), gzip(false) {}
+  Answer(const std::string& status, const std::string& pl, bool gz)
+      : status(status), pl(pl), gzip(gz) {}
+  std::string status, pl;
+  bool gzip;
+  std::unordered_map<std::string, std::string> params;
+};
+
+/*
+ * Virtual handler provider class
+ */
+class Handler {
+ public:
+  virtual Answer handle(const Req& request, int connection) const = 0;
+};
+
+/*
+ * Queue of connections to handle
+ */
+class Queue {
+ public:
+  void add(int c);
+  int get();
+
+ private:
+  std::mutex _mut;
+  std::queue<int> _jobs;
+  std::condition_variable _hasNew;
+};
+
+/*
+ * Socket wrapper
+ */
+class Socket {
+ public:
+  Socket(int port);
+  ~Socket();
+  int wait();
+
+ private:
+  int _sock;
+};
+
+/*
+ * Simple HTTP server, must provide a pointer to a class instance implementing
+ * virtual class Handler.
+ */
+class HttpServer {
+ public:
+  HttpServer(int port, const Handler* h) : HttpServer(port, h, 0) {}
+  HttpServer(int port, const Handler* h, size_t threads)
+      : _port(port), _handler(h), _threads(threads) {
+    if (!_threads) _threads = 8 * std::thread::hardware_concurrency();
+  }
+  void run();
+
+ private:
+  int _port;
+  Queue _jobs;
+  const Handler* _handler;
+  size_t _threads;
+
+  void handle();
+
+  static void send(int sock, Answer* aw);
+  static Req getReq(int connection);
+  static std::string compress(const std::string& str, std::string* enc);
+  static bool gzipSupport(const Req& req);
+};
+}  // http
+}  // util
+
+#endif  // UTIL_HTTP_SERVER_H_

src/util/json/Writer.cpp

@@ -0,0 +1,173 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <iomanip>
+#include "Writer.h"
+#include "util/String.h"
+using namespace util;
+using namespace json;
+
+using std::ostream;
+using std::string;
+using std::map;
+
+// _____________________________________________________________________________
+Writer::Writer(std::ostream* out)
+    : _out(out), _pretty(false), _indent(2), _floatPrec(10) {}
+
+// _____________________________________________________________________________
+Writer::Writer(std::ostream* out, size_t prec)
+    : _out(out), _pretty(false), _indent(2), _floatPrec(prec) {}
+
+// _____________________________________________________________________________
+Writer::Writer(std::ostream* out, size_t prec, bool pret)
+    : _out(out), _pretty(pret), _indent(2), _floatPrec(prec) {}
+
+// _____________________________________________________________________________
+Writer::Writer(std::ostream* out, size_t prec, bool pret, size_t indent)
+    : _out(out), _pretty(pret), _indent(indent), _floatPrec(prec) {}
+
+// _____________________________________________________________________________
+void Writer::obj() {
+  if (!_stack.empty() && _stack.top().type == OBJ)
+    throw WriterException("Object not allowed as key");
+  if (!_stack.empty() && _stack.top().type == KEY) _stack.pop();
+  if (!_stack.empty() && _stack.top().type == ARR) valCheck();
+  if (_stack.size() && _stack.top().type == ARR) prettor();
+  *_out << "{";
+  _stack.push({OBJ, 1});
+}
+
+// _____________________________________________________________________________
+void Writer::key(const std::string& k) {
+  if (_stack.empty() || _stack.top().type != OBJ)
+    throw WriterException("Keys only allowed in objects.");
+  if (!_stack.top().empty) (*_out) << "," << (_pretty ? " " : "");
+  _stack.top().empty = 0;
+  prettor();
+  *_out << "\"" << k << "\""
+        << ":" << (_pretty ? " " : "");
+  _stack.push({KEY, 1});
+}
+
+// _____________________________________________________________________________
+void Writer::valCheck() {
+  if (_stack.empty() || (_stack.top().type != KEY && _stack.top().type != ARR))
+    throw WriterException("Value not allowed here.");
+  if (!_stack.empty() && _stack.top().type == KEY) _stack.pop();
+  if (!_stack.empty() && _stack.top().type == ARR) {
+    if (!_stack.top().empty) (*_out) << "," << (_pretty ? " " : "");
+    _stack.top().empty = 0;
+  }
+}
+
+// _____________________________________________________________________________
+void Writer::val(const std::string& v) {
+  valCheck();
+  *_out << "\"" << util::jsonStringEscape(v) << "\"";
+}
+
+// _____________________________________________________________________________
+void Writer::val(const char* v) {
+  valCheck();
+  *_out << "\"" << util::jsonStringEscape(v) << "\"";
+}
+
+// _____________________________________________________________________________
+void Writer::val(bool v) {
+  valCheck();
+  *_out << (v ? "true" : "false");
+}
+
+// _____________________________________________________________________________
+void Writer::val(int v) {
+  valCheck();
+  *_out << v;
+}
+
+// _____________________________________________________________________________
+void Writer::val(double v) {
+  valCheck();
+  *_out << std::fixed << std::setprecision(_floatPrec) << v;
+}
+
+// _____________________________________________________________________________
+void Writer::val(Null) {
+  valCheck();
+  *_out << "null";
+}
+
+// _____________________________________________________________________________
+void Writer::val(const Val& v) {
+  switch (v.type) {
+    case Val::JSNULL:
+      val(Null());
+      return;
+    case Val::INT:
+      val(v.i);
+      return;
+    case Val::FLOAT:
+      val(v.f);
+      return;
+    case Val::BOOL:
+      val((bool)v.i);
+      return;
+    case Val::STRING:
+      val(v.str);
+      return;
+    case Val::ARRAY:
+      arr();
+      for (const Val& varr : v.arr) val(varr);
+      close();
+      return;
+    case Val::DICT:
+      obj();
+      for (const auto& vdic : v.dict) {
+        keyVal(vdic.first, vdic.second);
+      };
+      close();
+      return;
+  }
+}
+
+// _____________________________________________________________________________
+void Writer::arr() {
+  if (!_stack.empty() && _stack.top().type == OBJ)
+    throw WriterException("Array not allowed as key");
+  if (!_stack.empty() && _stack.top().type == KEY) _stack.pop();
+  if (!_stack.empty() && _stack.top().type == ARR) valCheck();
+  *_out << "[";
+  _stack.push({ARR, 1});
+}
+
+// _____________________________________________________________________________
+void Writer::prettor() {
+  if (_pretty) {
+    *_out << "\n";
+    for (size_t i = 0; i < _indent * _stack.size(); i++) (*_out) << " ";
+  }
+}
+
+// _____________________________________________________________________________
+void Writer::closeAll() {
+  while (!_stack.empty()) close();
+}
+
+// _____________________________________________________________________________
+void Writer::close() {
+  if (_stack.empty()) return;
+  switch (_stack.top().type) {
+    case OBJ:
+      _stack.pop();
+      prettor();
+      (*_out) << "}";
+      break;
+    case ARR:
+      _stack.pop();
+      (*_out) << "]";
+      break;
+    case KEY:
+      throw WriterException("Missing value.");
+  }
+}

src/util/json/Writer.h

@@ -0,0 +1,108 @@
+// Copyright 2018, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_JSON_WRITER_H_
+#define UTIL_JSON_WRITER_H_
+
+#include <map>
+#include <ostream>
+#include <stack>
+#include <string>
+#include <vector>
+
+namespace util {
+namespace json {
+
+class WriterException : public std::exception {
+ public:
+  WriterException(std::string msg) : _msg(msg) {}
+  ~WriterException() throw() {}
+
+  virtual const char* what() const throw() { return _msg.c_str(); };
+
+ private:
+  std::string _msg;
+};
+
+struct Null {};
+
+struct Val {
+  enum VAL_T { INT, FLOAT, STRING, ARRAY, DICT, BOOL, JSNULL };
+  VAL_T type;
+  int i;
+  double f;
+  std::string str;
+  std::vector<Val> arr;
+  std::map<std::string, Val> dict;
+
+  Val() { type = DICT; }
+  Val(Null) { type = JSNULL; }
+  Val(const std::vector<Val>& arrC) { arr = arrC, type = ARRAY; }
+  Val(const std::map<std::string, Val>& dC) { dict = dC, type = DICT; }
+  Val(const std::string& strC) { str = strC, type = STRING; }
+  Val(const char* strC) { str = strC, type = STRING; }
+  Val(double fC) { f = fC, type = FLOAT; }
+  Val(int iC) { i = iC, type = INT; }
+  Val(bool fC) { i = fC, type = BOOL; }
+};
+
+typedef int Int;
+typedef double Float;
+typedef bool Bool;
+typedef std::string String;
+typedef std::vector<Val> Array;
+typedef std::map<std::string, Val> Dict;
+
+// simple JSON writer class without much overhead
+class Writer {
+ public:
+  explicit Writer(std::ostream* out);
+  Writer(std::ostream* out, size_t prec);
+  Writer(std::ostream* out, size_t prec, bool pretty);
+  Writer(std::ostream* out, size_t prec, bool pretty, size_t indent);
+  ~Writer(){};
+
+  void obj();
+  void arr();
+  void key(const std::string& k);
+  void val(const std::string& v);
+  void val(const char* v);
+  void val(double v);
+  void val(int v);
+  void val(bool v);
+  void val(Null);
+  void val(const Val& v);
+  template <typename V>
+  void keyVal(const std::string& k, const V& v) {
+    key(k);
+    val(v);
+  }
+
+  void close();
+  void closeAll();
+
+ private:
+  std::ostream* _out;
+
+  enum NODE_T { OBJ, ARR, KEY };
+
+  struct Node {
+    NODE_T type;
+    bool empty;
+  };
+
+  std::stack<Node> _stack;
+
+  bool _pretty;
+  size_t _indent;
+  size_t _floatPrec;
+
+  void valCheck();
+  void prettor();
+};
+
+}  // namespace json
+}  // namespace util
+
+#endif  // UTIL_JSON_WRITER_H_

src/util/log/Log.h

@@ -0,0 +1,54 @@
+// Copyright 2017, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_LOG_LOG_H_
+#define UTIL_LOG_LOG_H_
+
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+
+#define VDEBUG 4
+#define DEBUG 3
+#define INFO 2
+#define WARN 1
+#define ERROR 0
+
+#ifndef LOGLEVEL
+#define LOGLEVEL 2
+#endif
+
+// compiler will optimize statement away if x > LOGLEVEL
+#define LOG(x) if (x <= LOGLEVEL) util::Log<x>().log()
+
+using std::setfill;
+using std::setw;
+using namespace std::chrono;
+
+namespace util {
+
+static const char* LOGS[] = {"ERROR", "WARN ", "INFO ", "DEBUG", "DEBUG"};
+
+template <char LVL>
+class Log {
+ public:
+  Log() { if (LVL == ERROR) os = &std::cerr; else os = &std::cout; }
+  ~Log() { (*os) << std::endl; }
+  std::ostream& log() { return ts() << LOGS[(size_t)LVL] << ": "; }
+
+ private:
+  std::ostream* os;
+  std::ostream& ts() {
+    char tl[20];
+    auto n = system_clock::now();
+    time_t tt = system_clock::to_time_t(n);
+    int m = duration_cast<milliseconds>(n-time_point_cast<seconds>(n)).count();
+    struct tm t = *localtime(&tt);
+    strftime(tl, 20, "%Y-%m-%d %H:%M:%S", &t);
+    return (*os) << "[" << tl << "." << setfill('0') << setw(3) << m << "] ";
+  }
+};
+}
+
+#endif  // UTIL_LOG_LOG_H_

src/util/tests/CMakeLists.txt

@@ -0,0 +1,6 @@
+include_directories(
+	${TRANSITMAP_INCLUDE_DIR}
+)
+
+add_executable(utilTest TestMain.cpp)
+target_link_libraries(utilTest util)

src/util/xml/XmlWriter.cpp

@@ -0,0 +1,182 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#include <algorithm>
+#include <map>
+#include <ostream>
+#include <stack>
+#include <string>
+#include "XmlWriter.h"
+
+using namespace util;
+using namespace xml;
+
+using std::ostream;
+using std::string;
+using std::map;
+
+// _____________________________________________________________________________
+XmlWriter::XmlWriter(std::ostream* out)
+    : _out(out), _pretty(false), _indent(4) {}
+
+// _____________________________________________________________________________
+XmlWriter::XmlWriter(std::ostream* out, bool pret)
+    : _out(out), _pretty(pret), _indent(4) {}
+
+// _____________________________________________________________________________
+XmlWriter::XmlWriter(std::ostream* out, bool pret, size_t indent)
+    : _out(out), _pretty(pret), _indent(indent) {}
+
+// _____________________________________________________________________________
+void XmlWriter::openTag(const string& tag, const map<string, string>& attrs) {
+  if (!_nstack.empty() && _nstack.top().t == COMMENT) {
+    throw XmlWriterException("Opening tags not allowed while inside comment.");
+  }
+
+  checkTagName(tag);
+  closeHanging();
+  doIndent();
+
+  *_out << "<" << tag;
+
+  for (auto kv : attrs) {
+    *_out << " ";
+    putEsced(_out, kv.first, '"');
+    *_out << "=\"";
+    putEsced(_out, kv.second, '"');
+    *_out << "\"";
+  }
+
+  _nstack.push(XmlNode(TAG, tag, true));
+}
+
+// _____________________________________________________________________________
+void XmlWriter::openTag(const string& tag) {
+  openTag(tag, map<string, string>());
+}
+
+// _____________________________________________________________________________
+void XmlWriter::openTag(const string& tag, const string& k, const string& v) {
+  map<string, string> kv;
+  kv[k] = v;
+  openTag(tag, kv);
+}
+
+// _____________________________________________________________________________
+void XmlWriter::openComment() {
+  // don't allow nested comments
+  if (!_nstack.empty() && _nstack.top().t == COMMENT) return;
+
+  closeHanging();
+  doIndent();
+
+  *_out << "<!-- ";
+
+  _nstack.push(XmlNode(COMMENT, "", false));
+}
+
+// _____________________________________________________________________________
+void XmlWriter::writeText(const string& text) {
+  if (_nstack.empty()) {
+    throw XmlWriterException("Text content not allowed in prolog / trailing.");
+  }
+  closeHanging();
+  doIndent();
+  putEsced(_out, text, ' ');
+}
+
+// _____________________________________________________________________________
+void XmlWriter::closeTag() {
+  while (!_nstack.empty() && _nstack.top().t == TEXT) _nstack.pop();
+
+  if (_nstack.empty()) return;
+
+  if (_nstack.top().t == COMMENT) {
+    _nstack.pop();
+    doIndent();
+    *_out << " -->";
+  } else if (_nstack.top().t == TAG) {
+    if (_nstack.top().hanging) {
+      *_out << " />";
+      _nstack.pop();
+    } else {
+      string tag = _nstack.top().pload;
+      _nstack.pop();
+      doIndent();
+      *_out << "</" << tag << ">";
+    }
+  }
+}
+
+// _____________________________________________________________________________
+void XmlWriter::closeTags() {
+  while (!_nstack.empty()) closeTag();
+}
+
+// _____________________________________________________________________________
+void XmlWriter::doIndent() {
+  if (_pretty) {
+    *_out << std::endl;
+    for (size_t i = 0; i < _nstack.size() * _indent; i++) *_out << " ";
+  }
+}
+
+// _____________________________________________________________________________
+void XmlWriter::closeHanging() {
+  if (_nstack.empty()) return;
+
+  if (_nstack.top().hanging) {
+    *_out << ">";
+    _nstack.top().hanging = false;
+  } else if (_nstack.top().t == TEXT) {
+    _nstack.pop();
+  }
+}
+
+// _____________________________________________________________________________
+void XmlWriter::putEsced(ostream* out, const string& str, char quot) {
+  if (!_nstack.empty() && _nstack.top().t == COMMENT) {
+    *out << str;
+    return;
+  }
+
+  for (const char& c : str) {
+    if (quot == '"' && c == '"')
+      *out << "&quot;";
+    else if (quot == '\'' && c == '\'')
+      *out << "&apos;";
+    else if (c == '<')
+      *out << "&lt;";
+    else if (c == '>')
+      *out << "&gt;";
+    else if (c == '&')
+      *out << "&amp;";
+    else
+      *out << c;
+  }
+}
+
+// _____________________________________________________________________________
+void XmlWriter::checkTagName(const string& str) const {
+  if (!isalpha(str[0]) && str[0] != '_')
+    throw XmlWriterException(
+        "XML elements must start with either a letter "
+        "or an underscore");
+
+  string begin = str.substr(0, 3);
+  std::transform(begin.begin(), begin.end(), begin.begin(), ::tolower);
+  if (begin == "xml")
+    throw XmlWriterException(
+        "XML elements cannot start with"
+        " XML, xml, Xml etc.");
+
+  for (const char& c : str) {
+    // we allow colons in tag names for primitive namespace support
+    if (!isalpha(c) && !isdigit(c) && c != '-' && c != '_' && c != '.' &&
+        c != ':')
+      throw XmlWriterException(
+          "XML elements can only contain letters, "
+          "digits, hyphens, underscores and periods.");
+  }
+}

src/util/xml/XmlWriter.h

@@ -0,0 +1,91 @@
+// Copyright 2016, University of Freiburg,
+// Chair of Algorithms and Data Structures.
+// Authors: Patrick Brosi <brosi@informatik.uni-freiburg.de>
+
+#ifndef UTIL_XML_XMLWRITER_H_
+#define UTIL_XML_XMLWRITER_H_
+
+#include <map>
+#include <ostream>
+#include <stack>
+#include <string>
+
+namespace util {
+namespace xml {
+
+class XmlWriterException : public std::exception {
+ public:
+  XmlWriterException(std::string msg) : _msg(msg) {}
+  ~XmlWriterException() throw() {}
+
+  virtual const char* what() const throw() { return _msg.c_str(); };
+
+ private:
+  std::string _msg;
+};
+
+// simple XML writer class without much overhead
+class XmlWriter {
+ public:
+  explicit XmlWriter(std::ostream* out);
+  XmlWriter(std::ostream* out, bool pretty);
+  XmlWriter(std::ostream* out, bool pretty, size_t indent);
+  ~XmlWriter(){};
+
+  // open tag without attributes
+  void openTag(const std::string& tag);
+
+  // open tag with single attribute (for convenience...)
+  void openTag(const std::string& tag, const std::string& key,
+               const std::string& val);
+
+  // open tag with attribute list
+  void openTag(const std::string& tag,
+               const std::map<std::string, std::string>& attrs);
+
+  // open comment
+  void openComment();
+
+  // write text
+  void writeText(const std::string& text);
+
+  // close tag
+  void closeTag();
+
+  // close all open tags, essentially closing the document
+  void closeTags();
+
+ private:
+  enum XML_NODE_T { TAG, TEXT, COMMENT };
+
+  struct XmlNode {
+    XmlNode(XML_NODE_T t, const std::string& pload, bool hanging)
+        : t(t), pload(pload), hanging(hanging) {}
+    XML_NODE_T t;
+    std::string pload;
+    bool hanging;
+  };
+
+  std::ostream* _out;
+  std::stack<XmlNode> _nstack;
+
+  bool _pretty;
+  size_t _indent;
+
+  // handles indentation
+  void doIndent();
+
+  // close "hanging" tags
+  void closeHanging();
+
+  // pushes XML escaped text to stream
+  void putEsced(std::ostream* out, const std::string& str, char quot);
+
+  // checks tag names for validiy
+  void checkTagName(const std::string& str) const;
+};
+
+}  // namespace xml
+}  // namespace util
+
+#endif  // UTIL_XML_XMLWRITER_H_