cmake_minimum_required(VERSION 3.

5)
project(networkit CXX)

if("${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}")

message(SEND_ERROR "In-source builds are not allowed.")
endif("${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}")

# BUILD OPTIONS
option(NETWORKIT_BUILD_CORE "Build NetworKit core library" ON)
option(NETWORKIT_BUILD_TESTS "Build NetworKit C++ tests" OFF)
option(NETWORKIT_QUIET_LOGGING "Set log level to QUIET by default (can still be
changed at run time)" OFF)
option(NETWORKIT_STATIC "Build static libraries" OFF)
option(NETWORKIT_MONOLITH "Build single library (and tests is requested; required
for shared lib)" ON)
option(NETWORKIT_NATIVE "Optimize for native architecture (often better
performance)" OFF)
option(NETWORKIT_WARNINGS "Issue more warnings" OFF)
option(NETWORKIT_WARNINGS_AS_ERRORS "Treat warnings as errors (except deprecated)"
OFF)
option(NETWORKIT_FLATINSTALL "Install into a flat directory structure (useful when
building a Python package)" OFF)
option(NETWORKIT_COVERAGE "Build with support for coverage" OFF)
set(NETWORKIT_PYTHON "" CACHE STRING "Directory containing Python.h. Implies
MONOLITH=TRUE")
set(NETWORKIT_PYTHON_SOABI "" CACHE STRING "Platform specific file extension.
Implies MONOLITH=TRUE")
set(NETWORKIT_WITH_SANITIZERS "" CACHE STRING "Uses sanitizers during the
compilation")
set(NETWORKIT_RELEASE_LOGGING "AUTO" CACHE STRING "Do not compile log messages at
levels TRACE or DEBUG (AUTO|ON|OFF)")
set(NETWORKIT_PYTHON_RPATH "" CACHE STRING "Build specific rpath references.")
set(NETWORKIT_EXT_TLX "" CACHE STRING "Absolute path for external tlx-library. If
not set, extlibs/tlx is used")

set (NETWORKIT_CXX_STANDARD "11" CACHE STRING "CXX Version to compile with.

Currently fixed to 11")

# Allow user to set installation paths relative to CMAKE_INSTALL_PREFIX

set(NETWORKIT_INSTALL_BIN_DIR "bin"
CACHE PATH "Installation directory for executables")
set(NETWORKIT_INSTALL_LIB_DIR "lib"
CACHE PATH "Installation directory for libraries")
set(NETWORKIT_INSTALL_INCLUDE_DIR "include"
CACHE PATH "Installation directory for header files")
set(NETWORKIT_INSTALL_PKGCONFIG_DIR "lib/pkgconfig"
CACHE PATH "Installation directory for pkg-config file")

if (NETWORKIT_PYTHON)
if (NOT NETWORKIT_MONOLITH)
message(FATAL_ERROR "When building NetworKit as a Python module,
NETWORKIT_MONOLITH=ON is required")
endif()
if(NOT NETWORKIT_PYTHON_SOABI)
message(WARNING "No platform-specific file extension provided. Do not
distribute library.")
endif()
endif()
if (NOT CMAKE_BUILD_TYPE)
message("Use Release Build Type as default")
set(CMAKE_BUILD_TYPE "Release")
endif()

################################################################################
# Compilation Flags
set(NETWORKIT_CXX_FLAGS "")
set(NETWORKIT_LINK_FLAGS "")

if (NETWORKIT_QUIET_LOGGING)
set(NETWORKIT_CXX_FLAGS "-DNETWORKIT_QUIET_LOGGING")
endif()

if (NETWORKIT_RELEASE_LOGGING STREQUAL "AUTO")

if (CMAKE_BUILD_TYPE STREQUAL "Release")
set(NETWORKIT_RELEASE_LOGGING "ON")
else()
set(NETWORKIT_RELEASE_LOGGING "OFF")
endif()
endif()

if (NETWORKIT_RELEASE_LOGGING STREQUAL "ON")

set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} -DNETWORKIT_RELEASE_LOGGING")
elseif(NOT NETWORKIT_RELEASE_LOGGING STREQUAL "OFF")
message(FATAL_ERROR "Unsupported setting ${NETWORKIT_RELEASE_LOGGING} for
NETWORKIT_RELEASE_LOGGING")
endif()

if (("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") OR

("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU") OR
("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang"))
if (NETWORKIT_NATIVE)
set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} -march=native")
endif()
if (NETWORKIT_WARNINGS)
set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} -Wall -Wextra
-Wpedantic")
endif()
if (NETWORKIT_WARNINGS_AS_ERRORS)
set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} -Werror -Wno-
error=deprecated-declarations")
endif()

elseif (MSVC)
set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} /DNETWORKIT_OMP2 /MP
/DNETWORKIT_WINDOWS")

# TTMath requires running an ASM for MSVC which we disable here at the cost
of worse performance
set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} /DTTMATH_NOASM=1")

else()
message(WARNING "Support only GCC, Clang, MSVC and AppleClang. Your compiler
may or may not work.")
endif()

# Checking sanitizer options; in both cases we include 'undefined'

set(NETWORKIT_CXX_SANITIZERS "")
if ("${NETWORKIT_WITH_SANITIZERS}" STREQUAL "address")
set(NETWORKIT_CXX_SANITIZERS "address,undefined")
elseif ("${NETWORKIT_WITH_SANITIZERS}" STREQUAL "leak")
set(NETWORKIT_CXX_SANITIZERS "address,leak,undefined")
elseif(NOT "${NETWORKIT_WITH_SANITIZERS}" STREQUAL "")
message(FATAL_ERROR "Unsupported option ${NETWORKIT_WITH_SANITIZERS}")
endif()

if (NOT "${NETWORKIT_CXX_SANITIZERS}" STREQUAL "")

set(NETWORKIT_CXX_FLAGS "-fsanitize=${NETWORKIT_CXX_SANITIZERS} $
{NETWORKIT_CXX_FLAGS}")
set(NETWORKIT_LINK_FLAGS "-fsanitize=${NETWORKIT_CXX_SANITIZERS} $
{NETWORKIT_LINK_FLAGS}")
endif()

# Check if coverage support is enabled

if (NETWORKIT_COVERAGE)
set(NETWORKIT_CXX_FLAGS "${NETWORKIT_CXX_FLAGS} --coverage")
set(NETWORKIT_LINK_FLAGS "${NETWORKIT_LINK_FLAGS} --coverage")
endif()

# finding or creating OpenMP target. This is likely to fail for CMake Version <
3.12.
find_package(OpenMP)

# FindOpenMP.cmake does not reliably find a user installed openmp library for
clang/llvm on
# both Linux- and macOS-systems (even for CMake Version >= 3.12). The following
section
# manually sets the required fields for clang-like compiler.
if(NOT OpenMP_FOUND)
if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "AppleClang")
# This will find default libomp-installations for homebrew/MacPorts
find_library(LIBOMP_PATH NAMES omp PATHS "/usr/local/opt/libomp/lib"
"/opt/local/lib/libomp")
find_path(LIBOMP_INCLUDE NAMES omp.h PATHS
"/usr/local/opt/libomp/include" "/opt/local/include/libomp")
if(LIBOMP_PATH AND LIBOMP_INCLUDE)
set(OpenMP_CXX_FLAGS "-Xpreprocessor -fopenmp -I$
{LIBOMP_INCLUDE}" CACHE STRING "Manually set" FORCE)
endif()
elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
if(DEFINED ENV{CONDA_PREFIX})
find_library(LIBOMP_PATH NAMES omp HINTS "$ENV{CONDA_PREFIX}/lib"
PATHS "/usr/lib" "/usr/lib64")
find_path(LIBOMP_INCLUDE NAMES omp.h HINTS
"$ENV{CONDA_PREFIX}/include"
PATHS "/usr/include")
else()
find_library(LIBOMP_PATH NAMES omp PATHS "/usr/lib" "/usr/lib64")
find_path(LIBOMP_INCLUDE NAMES omp.h PATHS "/usr/include")
endif()
if(LIBOMP_PATH AND LIBOMP_INCLUDE)
set(OpenMP_CXX_FLAGS "-fopenmp -I${LIBOMP_INCLUDE}" CACHE STRING
"Manually set" FORCE)
endif()
endif()
 # Set OpenMP-folders in case they are found with the aid of additional hints
if(LIBOMP_PATH AND LIBOMP_INCLUDE)
set(OpenMP_CXX_LIB_NAMES "omp" CACHE STRING "Manually set" FORCE)
set(OpenMP_omp_LIBRARY "${LIBOMP_PATH}" CACHE STRING "Manually set"
FORCE)
else()
message(FATAL_ERROR "libomp was not found, but necessary to run
NetworKit with ${CMAKE_CXX_COMPILER_ID}")
endif()

# After setting basic OpenMP-folders, run find_package again to set

everything. Also acts as a final sanity check.
find_package(OpenMP REQUIRED)
endif()

if(NOT TARGET OpenMP::OpenMP_CXX)

message("Creating custom OpenMP target for CMake Version < 3.12. Current
CMake Version ${CMAKE_VERSION}")
find_package(Threads REQUIRED)
add_library(OpenMP::OpenMP_CXX IMPORTED INTERFACE)
set_property(TARGET OpenMP::OpenMP_CXX
PROPERTY INTERFACE_COMPILE_OPTIONS ${OpenMP_CXX_FLAGS})
set_property(TARGET OpenMP::OpenMP_CXX
PROPERTY INTERFACE_LINK_LIBRARIES ${OpenMP_CXX_FLAGS}
Threads::Threads)
endif()

if (CMAKE_SIZEOF_VOID_P LESS 8)
if (MSVC)
message(FATAL_ERROR "NetworKit supports only 64bit builds.
Make sure to select a x64 target rather than x86,
e.g. when invoking cmake with -G")
else()
message(FATAL_ERROR "NetworKit supports only 64bit builds")
endif()
endif()

# specify linking flags for MacOS

if (APPLE)
set(NETWORKIT_LINK_FLAGS "-undefined dynamic_lookup ${NETWORKIT_LINK_FLAGS}")
endif()

if(NOT NETWORKIT_BUILD_CORE)
find_library(EXTERNAL_NETWORKIT_CORE NAMES networkit DOC "External NetworKit
core library")
endif()

if(NETWORKIT_FLATINSTALL)
set(NETWORKIT_LIB_DEST ".")
else()
set(NETWORKIT_LIB_DEST "lib/")
endif()

################################################################################
# Use TLX as a CMake submodule
if(NOT NETWORKIT_EXT_TLX)
if(EXISTS "${PROJECT_SOURCE_DIR}/extlibs/tlx/CMakeLists.txt")
add_subdirectory(extlibs/tlx)
else()
 message(FATAL_ERROR
"Missing TLX library in extlibs/tlx "
"Please run `git submodule update --init` to fetch the
submodule.")
endif()
else()
add_library(tlx STATIC IMPORTED)
set_target_properties(tlx PROPERTIES
IMPORTED_LOCATION "${NETWORKIT_EXT_TLX}/lib/libtlx.a"
INTERFACE_INCLUDE_DIRECTORIES "${NETWORKIT_EXT_TLX}/include/")
endif()

################################################################################
# NETWORKIT MODULES
if(NETWORKIT_BUILD_CORE AND NETWORKIT_MONOLITH)
if(NETWORKIT_STATIC)
add_library(networkit networkit/cpp/networkit.cpp)
else()
add_library(networkit SHARED networkit/cpp/networkit.cpp)
endif()

set_target_properties(networkit PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")

install(TARGETS networkit
LIBRARY DESTINATION ${NETWORKIT_LIB_DEST}
ARCHIVE DESTINATION ${NETWORKIT_LIB_DEST})

target_link_libraries(networkit PRIVATE tlx OpenMP::OpenMP_CXX)

target_include_directories(networkit BEFORE PUBLIC "$
{PROJECT_SOURCE_DIR}/include")
target_include_directories(networkit PUBLIC "$
{PROJECT_SOURCE_DIR}/extlibs/ttmath/")
endif()

if(NETWORKIT_PYTHON)
if(NOT EXISTS "${PROJECT_SOURCE_DIR}/networkit/_NetworKit.cpp")
message(FATAL_ERROR "networkit/_NetworKit.cpp is missing. Invoke Cython
manually.")
endif()

add_library(_NetworKit MODULE networkit/_NetworKit.cpp)

target_include_directories(_NetworKit BEFORE PUBLIC "$
{PROJECT_SOURCE_DIR}/include")
target_include_directories(_NetworKit PRIVATE "$
{PROJECT_SOURCE_DIR}/extlibs/ttmath/")
target_include_directories(_NetworKit PRIVATE "${NETWORKIT_PYTHON}")

if(NOT NETWORKIT_BUILD_CORE)
if(NOT EXTERNAL_NETWORKIT_CORE)
message(FATAL_ERROR "Core build is disabled but no external core
library was found.")
endif()
target_link_libraries(_NetworKit PRIVATE ${EXTERNAL_NETWORKIT_CORE})
else()
target_link_libraries(_NetworKit PRIVATE networkit)
endif()
 set_target_properties(_NetworKit PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}"
PREFIX ""
OUTPUT_NAME "_NetworKit.${NETWORKIT_PYTHON_SOABI}")
# If rpath-content is set explicitly, omit the dynamic binary path
if(NETWORKIT_PYTHON_RPATH)
set_target_properties(_NetworKit PROPERTIES
INSTALL_RPATH "${NETWORKIT_PYTHON_RPATH}")
else()
# DSOs on Apple OSes use different conventions for RPATH.
if(APPLE)
set_target_properties(_NetworKit PROPERTIES
INSTALL_RPATH "@loader_path")
else()
set_target_properties(_NetworKit PROPERTIES
INSTALL_RPATH "$ORIGIN")
endif()
endif()

target_link_libraries(_NetworKit PRIVATE tlx OpenMP::OpenMP_CXX)

install(TARGETS _NetworKit
LIBRARY DESTINATION ${NETWORKIT_LIB_DEST})
endif()

# Register a new NetworKit module named ${modname}

# Files additionally passed are interpreted as PUBLIC source files to this module
function(networkit_add_module modname)
if(NOT NETWORKIT_BUILD_CORE)
return()
endif()

if(NETWORKIT_MONOLITH)
# in case we are building a monolith, no submodule are registered
# and we simple add the source file to the networkkit target
set(MODULE_TARGET "networkit")
else()
set(MODULE_TARGET "networkit_${modname}")

add_library(${MODULE_TARGET}
${PROJECT_SOURCE_DIR}/networkit/cpp/networkit.cpp)

set_target_properties(${MODULE_TARGET} PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")

target_link_libraries(${MODULE_TARGET} PRIVATE tlx OpenMP::OpenMP_CXX)

target_include_directories(${MODULE_TARGET} BEFORE PUBLIC "$
{PROJECT_SOURCE_DIR}/include")
target_include_directories(${MODULE_TARGET} PUBLIC "$
{PROJECT_SOURCE_DIR}/extlibs/ttmath/")

# All tests added to this module will will also become a dependency
# of networkit_tests_MODNAME. This target hence allows to build all
# tests associated with this module
 if (NETWORKIT_BUILD_TESTS)
add_custom_target(networkit_tests_${modname})
endif()
endif()

# Add source files (it's important to mark them private; otherwise

# all targets linking to the lib, will recompile the objects from scratch)
foreach(file ${ARGN})
target_sources(${MODULE_TARGET}
PRIVATE ${CMAKE_CURRENT_LIST_DIR}/${file})
endforeach()
endfunction()

# Analogous to target_link_libraries with KEYWORDS.

# Use the module's name (without networkit_ prefix) for target.
# In case of monolithic builds, the call is ignored.
# To link against another module use networkit_module_link_modules
# Example: networkit_module_link_libraries(graph PRIVATE foobar_lib)
function(networkit_module_link_libraries modname)
set(options )
set(oneValueArgs )
set(multiValueArgs PRIVATE PUBLIC)
cmake_parse_arguments(NMLL
"${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})

if(NOT NETWORKIT_BUILD_CORE)
return()
endif()

if(NOT NETWORKIT_MONOLITH)
target_link_libraries(networkit_${modname}
PRIVATE ${NMLL_PRIVATE}
PUBLIC ${NMLL_PUBLIC})
endif()
endfunction()

# Specifiy inter-module dependencies. The function expects a list of at least

# two module names (without the networkit_ prefix). The first one add all following
# ones as dependencies. In case of monolith build, the function does nothing.
# Example: networkit_module_link_modules(io graph) # io depends on graph
function(networkit_module_link_modules modname)
if(NOT NETWORKIT_BUILD_CORE)
return()
endif()

if(NOT NETWORKIT_MONOLITH)
foreach(dep IN LISTS ARGN)
target_link_libraries(networkit_${modname} PUBLIC networkit_$
{dep})
endforeach()
endif()
endfunction()

################################################################################
# TESTING and BENCHMARKING
if (NETWORKIT_BUILD_TESTS)
enable_testing()
 if(EXISTS "${PROJECT_SOURCE_DIR}/extlibs/googletest/CMakeLists.txt")
if (MSVC)
# While by default MSVC projects link against the shared runtime
library
# (and hence also NetworKit), GTest defaults to the static
runtime lib.
# Both must not be mix, so we request GTest here to also use the
shared CRT.
set( gtest_force_shared_crt ON CACHE BOOL "Always use msvcrt.dll"
FORCE)
endif()
option(BUILD_GTEST "Builds the googletest subproject" ON)
option(BUILD_GMOCK "Builds the googlemock subproject" OFF)
add_subdirectory(extlibs/googletest)
else()
message(FATAL_ERROR
"Missing GoogleTest and GoogleMock in extlibs/googletest. "
"Please run `git submodule update --init` to fetch the
submodule.")
endif()

if (NETWORKIT_MONOLITH)
add_executable(networkit_tests networkit/cpp/Unittests-X.cpp)

target_link_libraries(networkit_tests
PRIVATE
gtest
networkit
tlx
OpenMP::OpenMP_CXX
)

set_target_properties(networkit_tests PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")

add_test(
NAME networkit_tests
COMMAND networkit_tests -t --srcloc
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
)

add_test(
NAME networkit_tests_no_assertions
COMMAND networkit_tests -r --srcloc
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
)

else()
add_library(networkit_gtest_main STATIC networkit/cpp/Unittests-X.cpp)

set_target_properties(networkit_gtest_main PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")

target_link_libraries(networkit_gtest_main
PUBLIC
 gtest
PRIVATE
tlx
networkit_auxiliary
OpenMP::OpenMP_CXX
)
endif()
endif()

# internal use only

# IS_TEST indicates whether add_test should be invoked for executable
# an whether it should be assigned to the module's test target
# MOD Name of module the test/benchmark assigned to. It will
# join its namespace, assigned to its test target and linked
# TESTNAME Name of the CPP File (excluding its .cpp extension). Will
# also be used to derive the test's name
function(networkit_add_extra IS_TEST MOD NAME)
if (NETWORKIT_BUILD_TESTS)
set(TEST_SOURCE ${CMAKE_CURRENT_LIST_DIR}/${NAME}.cpp)

if (NETWORKIT_MONOLITH)
target_sources(networkit_tests PRIVATE ${TEST_SOURCE})

else()
if (NOT TARGET networkit_${MOD})
MESSAGE(FATAL_ERROR "Unknown NetworKit module '${MOD}'")
endif()

set(TARGET_NAME "networkit_${MOD}_${NAME}")

add_executable(${TARGET_NAME} ${TEST_SOURCE})

target_link_libraries(${TARGET_NAME}
PRIVATE
gtest networkit_gtest_main
PRIVATE
networkit_${MOD}
tlx
OpenMP::OpenMP_CXX
)
set_target_properties(${TARGET_NAME} PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")

foreach(dep IN LISTS ARGN)

target_link_libraries(${TARGET_NAME} PRIVATE networkit_$
{dep})
endforeach()

if (${IS_TEST})
add_dependencies(networkit_tests_${MOD} ${TARGET_NAME})

add_test(
NAME "${MOD}/${NAME}"
COMMAND ${TARGET_NAME} -t --srcloc
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
)
 add_test(
NAME "${MOD}/${NAME}_no_assertions"
COMMAND ${TARGET_NAME} -r --srcloc
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
)
endif()
endif()
endif()
endfunction()

# Wrapper for networkit_add_extra with (IS_TEST=ON)

# Example: networkit_add_test(io SpecialIOGTest graph) compiles
# io/test/SpecialIOGTest.cpp, registers is as an test of networkit_tests_io
# and links it against io and graph.
function(networkit_add_test MOD NAME)
networkit_add_extra(ON ${MOD} ${NAME} ${ARGN})
endfunction(networkit_add_test)

# Wrapper for networkit_add_extra with (IS_TEST=OFF)

function(networkit_add_benchmark MOD NAME)
networkit_add_extra(OFF ${MOD} ${NAME} ${ARGN})
endfunction(networkit_add_benchmark)

################################################################################
# Benchmarks

# In case of monolithic builds we add the target networkit_benchmarks, and later

add
# source files via networkit_add_gbenchmark. In case of non-monolithic builds, each
# networkit_add_test creates it own target.
if (NETWORKIT_BUILD_BENCHMARKS AND NETWORKIT_MONOLITH)
add_executable(networkit_benchmarks networkit/cpp/networkit.cpp)

target_link_libraries(networkit_benchmarks
PRIVATE
benchmark_main benchmark
networkit
)

set_target_properties(networkit_tests PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")
endif()

function(networkit_add_gbenchmark MOD NAME)

if (NETWORKIT_BUILD_BENCHMARKS)
set(BENCH_SOURCE ${CMAKE_CURRENT_LIST_DIR}/${NAME}.cpp)

if (NETWORKIT_MONOLITH)
target_sources(networkit_benchmarks PRIVATE ${BENCH_SOURCE})

else()
if (NOT TARGET networkit_${MOD})
MESSAGE(FATAL_ERROR "Unknown NetworKit module '${MOD}'")
endif()

set(TARGET_NAME "networkit_${MOD}_${NAME}")
 add_executable(${TARGET_NAME} ${BENCH_SOURCE})
message("${TARGET_NAME}: ${BENCH_SOURCE}")

target_link_libraries(${TARGET_NAME}
PRIVATE
benchmark_main benchmark
networkit_${MOD})

set_target_properties(${TARGET_NAME} PROPERTIES
CXX_STANDARD ${NETWORKIT_CXX_STANDARD}
COMPILE_FLAGS "${NETWORKIT_CXX_FLAGS}"
LINK_FLAGS "${NETWORKIT_LINK_FLAGS}")

foreach(dep IN LISTS ARGN)

target_link_libraries(${TARGET_NAME} PRIVATE networkit_$
{dep})
endforeach()
endif()
endif()
endfunction(networkit_add_gbenchmark)

################################################################################
# Documentation

find_program(SPHINX_EXECUTABLE
NAMES
sphinx-build sphinx-build.exe
PATHS
/usr/bin
/usr/local/bin
/opt/local/bin
DOC "Sphinx documentation generator")

if (NOT SPHINX_EXECUTABLE)
message(STATUS "sphinx-build not found. Disable documentation targets")

else()
message(STATUS "Found sphinx-build: ${SPHINX_EXECUTABLE}")
add_custom_target(general_docs
COMMAND rm -rf htmldocs
COMMAND ${SPHINX_EXECUTABLE} ${CMAKE_SOURCE_DIR}/docs htmldocs)

add_custom_target(cpp_api_docs DEPENDS general_docs

COMMAND sed s:@BUILDDIR@:${CMAKE_CURRENT_BINARY_DIR}:
${CMAKE_SOURCE_DIR}/docs/cpp_api/Doxyfile.in |
doxygen -
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})

add_custom_target(docs DEPENDS general_docs cpp_api_docs)

endif()

################################################################################
# Subdirectories
add_subdirectory(networkit/cpp)

# Install NetworKit header files

set(NETWORKIT_LIBRARIES networkit)
install(DIRECTORY include/networkit
 DESTINATION ${NETWORKIT_INSTALL_INCLUDE_DIR}
FILES_MATCHING PATTERN "*.hpp")

# Install ttmath header files

install(DIRECTORY extlibs/ttmath/ttmath
DESTINATION ${NETWORKIT_INSTALL_INCLUDE_DIR}
FILES_MATCHING PATTERN "*.hpp")

################################################################################
# Prepare pkg-config file

set(NETWORKIT_LIBNAME networkit)
execute_process(COMMAND python3 -c "from version import version; print(version,
end='')"
WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
OUTPUT_VARIABLE NETWORKIT_VERSION)
configure_file(networkit.pc
"${PROJECT_BINARY_DIR}/${NETWORKIT_LIBNAME}.pc" @ONLY)

if(NETWORKIT_INSTALL_PKGCONFIG_DIR)
INSTALL(FILES ${PROJECT_BINARY_DIR}/${NETWORKIT_LIBNAME}.pc
DESTINATION ${NETWORKIT_INSTALL_PKGCONFIG_DIR})
endif()