cmake function for using a modular library with multiple targets - cmake

Question

I develop some library which is mainly some set of interfaces to third-party packages. In my library there are core routines which need to be compiled anyway and a set of optional ones which one need to compile in case of using it in the code.
Let me illustrate it on some example.
Library
|---interfaces
| |---first
| | |---CMakeLists.txt
| | |---...
| |---second
| |---CMakeLists.txt
| |---...
|---core_routines
| |---CMakeLists.txt
| |---...
|---dependencies.cmake
This is a tree of my project. My library is a header-only. I need to write cmake function which one can use to efficiently add required submodules in its project.
Currently I use my own quite ugly solution. Namely, below you can see how my dependencies.cmake file looks like
#first interface dependencies
if(first)
link_directories(...)
include_directories(...)
add_subdirectory(${SOME_PATH}/interfaces/first
"${CMAKE_CURRENT_BINARY_DIR}/first")
endif()
#second interface dependencies
if(second)
...
endif()
#core routines
add_subdirectory(${SOME_PATH}/core_routines/
"${CMAKE_CURRENT_BINARY_DIR}/core_routines")
#function for adding required libs to new target
function(add_new_target new_target)
target_link_libraries(
${new_target} core_lib
)
if(first)
target_link_libraries(
${new_target} first_lib
)
endif()
if(second)
target_link_libraries(
...
)
endif()
endfunction(add_new_target)
Now, when I use my library in some code, the corresponding CMakeLists.txt file looks like
set(first ON)
set(second ON)
include(dependencies.cmake)
add_executable(main.exe main.cpp)
add_new_target(main.exe)
I use this way to compile the example since, as far as I know, one needs to specify link_directories and include_directories before adding new executable and then specify required libraries with target_link_libraries after it. Correct me if I am wrong.
My question is whether it is possible to write something better in this case? I need to keep modular structure of my code because, first, some interfaces require of using libraries which can be not installed on user PC, and, second, the main usage of my library will be in projects with cmake file which includes a lot of different targets, so I need to have some function which can specify required libraries and interfaces depending on user request.

Answer 1

link_directories() and include_directories() are not the modern way. They are too broad. By default, almost everything in modern CMake is target_* based.
Each sub-directory target should already be using target_include_directories() and target_link_libraries() with "PUBLIC" or "INTERFACE" for transitive dependencies, i.e. to carry along what is needed to successfully include and link them.
If these libraries are third party and don't already bundle their transitive dependencies, then you can do it for them using set_target_properties() with the "INTERFACE_INCLUDE_DIRECTORIES" AND "INTERFACE_LINK_LIBRARIES" properties.

Answer 2

Supply a list of all the libraries that client programs need to link. This would be a great deal like the builtin FindBoost module, which takes in a list of components, then prepares variables for each component, plus BOOST_LIBRARIES which is a list of all of the components.
set(my_component_libraries core_lib)
if(first)
list(APPEND my_component_libraries first_lib)
endif()
# etc.
set(my_component_libraries ${my_component_libraries} PARENT_SCOPE)
This way you leave the actual linking up to the users.
If you write your CMake interface to be find_package compatible, you can actually use the COMPONENTS interface to find_package, just like Boost.