CMakeLists.txt

cmake_minimum_required(VERSION 3.0.2)
project(file_utils)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Debug)
endif()

message(STATUS "Build type: " ${CMAKE_BUILD_TYPE})

if(CMAKE_BUILD_TYPE STREQUAL "Debug")
  set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -Wunused-variable"
  )# Set the debug flag for C++ compiler when in debug mode
endif()

set(CMAKE_CXX_STANDARD 20) # for better file path handling

# link libs only when needed
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--as-needed")

list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) # for third-party
                                                           # library finding

# Compile as C++20, supported in ROS Kinetic and newer
add_compile_options(-std=c++20)

# Find catkin macros and libraries if COMPONENTS list like find_package(catkin
# REQUIRED COMPONENTS xyz) is used, also find other catkin packages

find_package(catkin REQUIRED COMPONENTS roscpp)
list(APPEND INCLUDE_LIST ${catkin_INCLUDE_DIRS})
list(APPEND LIB_LIST ${catkin_LIBRARIES})

# System dependencies are found with CMake's conventions find_package(Boost
# REQUIRED COMPONENTS system)

# Boost
find_package(Boost REQUIRED)
list(APPEND CATKIN_SYSTEM_DEPENDS_LIST Boost)
list(APPEND INCLUDE_LIST ${Boost_INCLUDE_DIRS})
list(APPEND LIB_LIST ${Boost_LIBRARIES})

# Gflags
find_package(Gflags REQUIRED)
list(APPEND CATKIN_SYSTEM_DEPENDS_LIST GFLAGS)
list(APPEND INCLUDE_LIST ${GFLAGS_INCLUDE_DIRS})
list(APPEND LIB_LIST ${GFLAGS_LIBRARIES})

# Glog
find_package(Glog REQUIRED)
list(APPEND CATKIN_SYSTEM_DEPENDS_LIST GLOG)
list(APPEND INCLUDE_LIST ${GLOG_INCLUDE_DIRS})
list(APPEND LIB_LIST ${GLOG_LIBRARIES})

# GTest
find_package(GTest REQUIRED)
list(APPEND CATKIN_SYSTEM_DEPENDS_LIST GTEST)
list(APPEND INCLUDE_LIST ${GTEST_INCLUDE_DIRS})
list(APPEND LIB_LIST GTest::gtest)

# csv-parser add_subdirectory(third-party/csv-parser) list(APPEND
# CATKIN_SYSTEM_DEPENDS_LIST CSV) list(APPEND INCLUDE_LIST
# ${CMAKE_CURRENT_SOURCE_DIR}/third-party/csv-parser/include) list(APPEND
# LIB_LIST csv)
list(APPEND INCLUDE_LIST
     ${CMAKE_CURRENT_SOURCE_DIR}/third-party/csv-parser/single_include)

# yaml-cpp
add_subdirectory(third-party/yaml-cpp)
list(APPEND CATKIN_SYSTEM_DEPENDS_LIST YAML_CPP)
list(APPEND INCLUDE_LIST ${YAML_CPP_INCLUDE_DIR})
list(APPEND LIB_LIST yaml-cpp::yaml-cpp)

# Uncomment this if the package has a setup.py. This macro ensures modules and
# global scripts declared therein get installed See
# http://ros.org/doc/api/catkin/html/user_guide/setup_dot_py.html
catkin_python_setup()

# ##############################################################################
# Declare ROS messages, services and actions ##
# ##############################################################################

# To declare and build messages, services or actions from within this package,
# follow these steps: * Let MSG_DEP_SET be the set of packages whose message
# types you use in your messages/services/actions (e.g. std_msgs,
# actionlib_msgs, ...). * In the file package.xml: * add a build_depend tag for
# "message_generation" * add a build_depend and a exec_depend tag for each
# package in MSG_DEP_SET * If MSG_DEP_SET isn't empty the following dependency
# has been pulled in but can be declared for certainty nonetheless: * add a
# exec_depend tag for "message_runtime" * In this file (CMakeLists.txt): * add
# "message_generation" and every package in MSG_DEP_SET to find_package(catkin
# REQUIRED COMPONENTS ...) * add "message_runtime" and every package in
# MSG_DEP_SET to catkin_package(CATKIN_DEPENDS ...) * uncomment the add_*_files
# sections below as needed and list every .msg/.srv/.action file to be processed
# * uncomment the generate_messages entry below * add every package in
# MSG_DEP_SET to generate_messages(DEPENDENCIES ...)

# Generate messages in the 'msg' folder add_message_files( FILES Message1.msg
# Message2.msg )

# Generate services in the 'srv' folder add_service_files( FILES Service1.srv
# Service2.srv )

# Generate actions in the 'action' folder add_action_files( FILES Action1.action
# Action2.action )

# Generate added messages and services with any dependencies listed here
# generate_messages( DEPENDENCIES std_msgs )

# ##############################################################################
# Declare ROS dynamic reconfigure parameters ##
# ##############################################################################

# To declare and build dynamic reconfigure parameters within this package,
# follow these steps: * In the file package.xml: * add a build_depend and a
# exec_depend tag for "dynamic_reconfigure" * In this file (CMakeLists.txt): *
# add "dynamic_reconfigure" to find_package(catkin REQUIRED COMPONENTS ...) *
# uncomment the "generate_dynamic_reconfigure_options" section below and list
# every .cfg file to be processed

# Generate dynamic reconfigure parameters in the 'cfg' folder
# generate_dynamic_reconfigure_options( cfg/DynReconf1.cfg cfg/DynReconf2.cfg )

# ##############################################################################
# catkin specific configuration ##
# ##############################################################################
# The catkin_package macro generates cmake config files for your package Declare
# things to be passed to dependent projects INCLUDE_DIRS: uncomment this if your
# package contains header files LIBRARIES: libraries you create in this project
# that dependent projects also need CATKIN_DEPENDS: catkin_packages dependent
# projects also need DEPENDS: system dependencies of this project that dependent
# projects also need

catkin_package(
  INCLUDE_DIRS
  include
  ${INCLUDE_LIST}
  LIBRARIES
  ${PROJECT_NAME}
  CATKIN_DEPENDS
  roscpp
  DEPENDS
  ${CATKIN_SYSTEM_DEPENDS_LIST})

# ##############################################################################
# Build ##
# ##############################################################################

# Specify additional locations of header files Your package locations should be
# listed before other locations

include_directories(include ${INCLUDE_LIST})

# Declare a C++ library
add_library(${PROJECT_NAME} SHARED src/Files.cpp)
target_link_libraries(${PROJECT_NAME} PUBLIC ${LIB_LIST})

# Add cmake target dependencies of the library as an example, code may need to
# be generated before libraries either from message generation or dynamic
# reconfigure
add_dependencies(${PROJECT_NAME} ${${PROJECT_NAME}_EXPORTED_TARGETS}
                 ${catkin_EXPORTED_TARGETS})

# Declare a C++ executable With catkin_make all packages are built within a
# single CMake context The recommended prefix ensures that target names across
# packages don't collide add_executable(${PROJECT_NAME}_node
# src/${PROJECT_NAME}_node.cpp)

# Rename C++ executable without prefix The above recommended prefix causes long
# target names, the following renames the target back to the shorter version for
# ease of user use e.g. "rosrun someones_pkg node" instead of "rosrun
# someones_pkg someones_pkg_node" set_target_properties(${PROJECT_NAME}_node
# PROPERTIES OUTPUT_NAME node PREFIX "")

# Add cmake target dependencies of the executable same as for the library above
# add_dependencies(${PROJECT_NAME}_node ${${PROJECT_NAME}_EXPORTED_TARGETS}
# ${catkin_EXPORTED_TARGETS})

# Specify libraries to link a library or executable target against
# target_link_libraries(${PROJECT_NAME}_node ${LIB_LIST})

# ##############################################################################
# Install ##
# ##############################################################################

# all install targets should use catkin DESTINATION variables See
# http://ros.org/doc/api/catkin/html/adv_user_guide/variables.html

# Mark executable scripts (Python etc.) for installation in contrast to
# setup.py, you can choose the destination catkin_install_python(PROGRAMS
# scripts/my_python_script DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION} )

# Mark executables for installation See
# http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_executables.html
# install(TARGETS ${PROJECT_NAME}_node RUNTIME DESTINATION
# ${CATKIN_PACKAGE_BIN_DESTINATION} )

# Mark libraries for installation See
# http://docs.ros.org/melodic/api/catkin/html/howto/format1/building_libraries.html
install(
  TARGETS ${PROJECT_NAME}
  ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
  LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
  RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION})

# Mark cpp header files for installation
install(DIRECTORY include/${PROJECT_NAME}/
        DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION})
# FILES_MATCHING PATTERN "*.h" PATTERN ".svn" EXCLUDE )

# Mark other files for installation (e.g. launch and bag files, etc.)
# install(FILES # myfile1 # myfile2 DESTINATION
# ${CATKIN_PACKAGE_SHARE_DESTINATION} )

# ##############################################################################
# Testing ##
# ##############################################################################

# Add gtest based cpp test target and link libraries
# catkin_add_gtest(${PROJECT_NAME}-test test/test_camera_driver.cpp) if(TARGET
# ${PROJECT_NAME}-test) target_link_libraries(${PROJECT_NAME}-test
# ${PROJECT_NAME}) endif()

# Add folders to be run by python nosetests catkin_add_nosetests(test)