CODEWITHSUNDEEP
c++cmake
Oleg
Oleg

Reputation: 506

How to install a cmake package in a custom directory and link it with target_link_libraries() by name?

I have a custom library which exports include/, lib/ and lib/cmake/ which contains MyProjectConfig.cmake with the following contents:

set(MyProject_INCLUDE_DIRS "/home/.../cmake-build-debug/thirdparty/myproj/include")
set(MyProject_LIBRARY_DIRS "/home/.../cmake-build-debug/thirdparty/myproj/lib")
set(MyProject_LIBRARIES "MyProject")

message(STATUS "MyProject found. Headers: ${MyProject_INCLUDE_DIRS}")

I use it in another project like this:

include(ExternalProject)

ExternalProject_Add(MyProjectExternal
    PREFIX "${CMAKE_BINARY_DIR}/external/myproject"
    GIT_REPOSITORY "[email protected]:myproject.git"
    GIT_TAG "master"
    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/thirdparty/myproject
)

add_dependencies(${PROJECT_NAME} MyProjectExternal)

# prevent error on first project use when dir doesn't exist
if(EXISTS ${CMAKE_BINARY_DIR}/thirdparty/myproject/lib) 

    find_package(MyProject REQUIRED HINTS ${CMAKE_BINARY_DIR}/thirdparty/myproject/lib/cmake)
    find_library(MyProject_LIB MyProject HINTS ${MyProject_LIBRARY_DIRS})
    target_link_libraries(${PROJECT_NAME} PUBLIC ${MyProject_LIB})
    target_include_directories(${PROJECT_NAME} PRIVATE ${MyProject_INCLUDE_DIRS})

endif()

I expected that the variables set in MyProjectConfig.cmake would be picked up automatically by cmake to find the library by name and this would work:

find_package(MyProject REQUIRED HINTS ${CMAKE_BINARY_DIR}/thirdparty/myproject/lib/cmake)
target_link_libraries(${PROJECT_NAME} PUBLIC MyProject)

But it doesn't:

[ 87%] Built target MyProjectExternal
[ 90%] Linking CXX executable RootProject
/usr/bin/ld: cannot find -lMyProject
collect2: error: ld returned 1 exit status

Part II (as requested here) The full code and the steps to reproduce the problem

Library Code

CMakeLists.txt

cmake_minimum_required(VERSION 3.8)
project(MyLib VERSION 1.0.0 LANGUAGES CXX)

add_library(${PROJECT_NAME} SHARED
    src/mylib/hello.cpp
    )
target_include_directories(${PROJECT_NAME}
    PUBLIC $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include> $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
    )

set_target_properties(${PROJECT_NAME} PROPERTIES
    CXX_STANDARD 11
    CXX_STANDARD_REQUIRED YES
    CXX_EXTENSIONS NO
    )

include(cmake/install.cmake)

cmake/install.cmake

include(GNUInstallDirs)
install(TARGETS ${PROJECT_NAME} EXPORT ${PROJECT_NAME}Targets
    ARCHIVE  DESTINATION ${CMAKE_INSTALL_LIBDIR}
    LIBRARY  DESTINATION ${CMAKE_INSTALL_LIBDIR}
    RUNTIME  DESTINATION ${CMAKE_INSTALL_BINDIR}
    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
    PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
)
install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

include(GenerateExportHeader)
generate_export_header(${PROJECT_NAME}
    EXPORT_MACRO_NAME EXPORT
    NO_EXPORT_MACRO_NAME NO_EXPORT
    PREFIX_NAME MYLIB_
    EXPORT_FILE_NAME ${CMAKE_BINARY_DIR}/include-exports/mylib/export.h)
target_include_directories(${PROJECT_NAME}
    PUBLIC
        $<BUILD_INTERFACE:${CMAKE_BINARY_DIR}/include-exports>
        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
)
install(DIRECTORY ${CMAKE_BINARY_DIR}/include-exports/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})

include(CMakePackageConfigHelpers)
set_property(TARGET ${PROJECT_NAME} PROPERTY VERSION ${PROJECT_VERSION})
set_property(TARGET ${PROJECT_NAME} PROPERTY SOVERSION ${PROJECT_VERSION_MAJOR})
set_property(TARGET ${PROJECT_NAME} PROPERTY INTERFACE_${PROJECT_NAME}_MAJOR_VERSION ${PROJECT_VERSION_MAJOR})
set_property(TARGET ${PROJECT_NAME} APPEND PROPERTY COMPATIBLE_INTERFACE_STRING ${PROJECT_VERSION_MAJOR})
write_basic_package_version_file(
    "${CMAKE_BINARY_DIR}/CMakePackage/${PROJECT_NAME}ConfigVersion.cmake"
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY SameMajorVersion
)
export(EXPORT ${PROJECT_NAME}Targets
    FILE "${CMAKE_BINARY_DIR}/CMakePackage/${PROJECT_NAME}.cmake"
)
SET(CONFIG_SOURCE_DIR ${CMAKE_SOURCE_DIR})
SET(CONFIG_DIR ${CMAKE_BINARY_DIR})
SET(${PROJECT_NAME}_INCLUDE_DIR "\${${PROJECT_NAME}_SOURCE_DIR}/include")
configure_package_config_file(${CMAKE_SOURCE_DIR}/cmake/Config.cmake.in
    "${CMAKE_BINARY_DIR}/CMakePackage/${PROJECT_NAME}Config.cmake"
    INSTALL_DESTINATION lib/cmake/${PROJECT_NAME}
    PATH_VARS ${PROJECT_NAME}_INCLUDE_DIR)
install(EXPORT ${PROJECT_NAME}Targets
    FILE ${PROJECT_NAME}.cmake
    DESTINATION lib/cmake/${PROJECT_NAME}
)
install(
    FILES
        "${CMAKE_BINARY_DIR}/CMakePackage/${PROJECT_NAME}Config.cmake"
        "${CMAKE_BINARY_DIR}/CMakePackage/${PROJECT_NAME}ConfigVersion.cmake"
    DESTINATION lib/cmake/${PROJECT_NAME}
    COMPONENT Devel
)

cmake/Config.cmake.in

@PACKAGE_INIT@

set_and_check(@PROJECT_NAME@_INCLUDE_DIRS "@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_INCLUDEDIR@")
set_and_check(@PROJECT_NAME@_LIBRARY_DIRS "@CMAKE_INSTALL_PREFIX@/@CMAKE_INSTALL_LIBDIR@")
set(@PROJECT_NAME@_LIBRARIES "@PROJECT_NAME@")

check_required_components(@PROJECT_NAME@)

message(STATUS "@PROJECT_NAME@ found. Headers: ${@PROJECT_NAME@_INCLUDE_DIRS}")

include/mylib/hello.h

#ifndef MYLIB_HELLO_H
#define MYLIB_HELLO_H

#include <mylib/export.h>

namespace mylib {
    extern MYLIB_EXPORT void hello();
}

#endif

src/mylib/hello.cpp

#include <mylib/hello.h>
#include <iostream>

namespace mylib {
    void hello() {
        std::cout << "Hello, MyLib!" << std::endl;
    }
}

Application Code

CMakeLists.txt

cmake_minimum_required(VERSION 3.8)
project(MyLibConsumer VERSION 1.0.0 LANGUAGES CXX)

add_executable(${PROJECT_NAME}
    main.cpp)

set_target_properties(${PROJECT_NAME} PROPERTIES
    CXX_STANDARD 11
    CXX_STANDARD_REQUIRED YES
    CXX_EXTENSIONS NO
    )

include(ExternalProject)
set(LIB_INSTALL_DIR ${CMAKE_BINARY_DIR}/thirdparty/mylib)
ExternalProject_Add(MyLibExternal
    PREFIX "${CMAKE_BINARY_DIR}/external/mylib"
    GIT_REPOSITORY "https://github.com/...git"
    GIT_TAG "mylib"
    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${LIB_INSTALL_DIR}
    )
add_dependencies(${PROJECT_NAME} MyLibExternal)
if(EXISTS ${LIB_INSTALL_DIR}/lib) # prevent error on first cmake load
    find_package(MyLib REQUIRED HINTS ${LIB_INSTALL_DIR}/lib/cmake)

    # fixme: make this work
    target_link_libraries(${PROJECT_NAME} PUBLIC MyLib)

    # to test: comment the above line and uncomment the below lines
    #find_library(MyLib_LIB MyLib HINTS ${MyLib_LIBRARY_DIRS})
    #target_link_libraries(${PROJECT_NAME} PRIVATE ${MyLib_LIB})
    #target_include_directories(${PROJECT_NAME} PRIVATE ${MyLib_INCLUDE_DIRS})
endif()

main.cpp

#include <mylib/hello.h>

int main()
{
    mylib::hello();
    return 0;
}

The Error

main.cpp:1:25: fatal error: mylib/hello.h: No such file or directory
 #include <mylib/hello.h>
                         ^

Using the MyLib_* variables created by find_package() fixes the problem but it's too verbose.

As suggested [here][4]:

However, recommended way is to use CMake functionality for create configuration file. Such way, fully-fledged target will be created, and can be used for linking.

How to do that?

I want to use my library in 2 steps, like Qt:

  1. find_package(Qt5Widgets)
  2. target_link_libraries(myApp Qt5::Widgets)

Upvotes: 2

Views: 11178

Answers (2)

Oleg
Oleg

Reputation: 506

Just include MyProject.cmake in MyProjectConfig.cmake (it is not included by default)

include(${CMAKE_CURRENT_LIST_DIR}/MyProject.cmake)

The final version of key files:

LIBRARY/cmake/Config.cmake.in

Removed redundant variables: *_INCLUDE_DIRS, *_LIBRARY_DIRS, *_LIBRARIES

@PACKAGE_INIT@

include(${CMAKE_CURRENT_LIST_DIR}/@[email protected])

check_required_components(@PROJECT_NAME@)

message(STATUS "@PROJECT_NAME@ found.")

EXECUTABLE/CMakeLists.txt

Moved external projects before executable and return() if external projects are not built.

cmake_minimum_required(VERSION 3.8)
project(MyLibConsumer VERSION 1.0.0 LANGUAGES CXX)

set(LIB_INSTALL_DIR ${CMAKE_BINARY_DIR}/thirdparty/mylib)
include(ExternalProject)
ExternalProject_Add(MyLibExternal
    PREFIX "${CMAKE_BINARY_DIR}/external/mylib"
    GIT_REPOSITORY "https://github.com/arteniioleg/stackoverflow-question-46772541.git"
    GIT_TAG "mylib"
    CMAKE_ARGS -DCMAKE_INSTALL_PREFIX=${LIB_INSTALL_DIR}
    )
if(NOT EXISTS ${LIB_INSTALL_DIR}/lib)
    # Happens on first CMake run.
    # Can't continue because the below `find_package(REQUIRED)` will fail.
    # Build all external project targets then rerun CMake and build the project target.
    message(AUTHOR_WARNING "Build all external projects then reload cmake.")
    return()
endif()

add_executable(${PROJECT_NAME} main.cpp)
set_target_properties(${PROJECT_NAME} PROPERTIES
    CXX_STANDARD 11
    CXX_STANDARD_REQUIRED YES
    CXX_EXTENSIONS NO
    )

add_dependencies(${PROJECT_NAME} MyLibExternal)
find_package(MyLib REQUIRED HINTS ${LIB_INSTALL_DIR})
target_link_libraries(${PROJECT_NAME} PRIVATE MyLib)

Upvotes: 1

Tsyvarev
Tsyvarev

Reputation: 65928

I expected that the variables set in MyProjectConfig.cmake would be picked up automatically by cmake to find the library by name.

The most "magic" in find_package command is how it searches *Config.cmake script. After the script is found, it is simply executed in the context of the caller.

In you case, CMake sets variables MyProject_INCLUDE_DIRS, MyProject_LIBRARY_DIRS and MyProject_LIBRARIES. Nothing more. It doesn't create MyProject target and so.

If you want find_package() preparing linking with MyProject library, you need to write your MyProjectConfig.cmake script accordingly (e.g., call link_directories() from it).

However, recommended way is to use CMake functionality for create configuration file. Such way, fully-fledged target will be created, and can be used for linking. See cmake-packages documentation for more info.

Upvotes: 0

Related Questions