Using qi_stage_lib

Basic usage

Using qi_stage_lib: should “just works” when using a target created with qi_create_lib, provided that you call include_directories before staging the library:

include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
qi_create_lib(foo foo/foo.cpp foo/foo.hpp)
qi_stage_lib(foo)

Advanced usage

As the documentation explains, qi_stage_lib accepts various argument, but most of them are guessed automatically.

Let us have a look on a few cases where what qibuild guesses can be wrong, and how to fix it.

Using qi_stage_lib with custom DEPENDS

Let us assume you have a library named ‘bar’, depending privately on a library named ‘foo’ and publicly on boost chrono.

Your CMake code may look like this:

qi_create_lib(bar bar/bar.hpp bar/bar.cpp)
qi_stage_lib(bar)

qi_create_lib(foo foo/foo.hpp foo/foo.cpp)
qi_use_lib(foo bar boost_chrono)
qi_stage_lib(foo)
qi_install_header(foo/foo.hpp SUBFOLDER foo)

By default, the generated foo-config.cmake file will contain FOO_DEPENDS=bar;boost_chrono;boost_system, thanks to the call to qi_use_lib and because boost chrono itself depends on boost system.

So here you must make sure that the generated foo-config.cmake file does not list BAR in FOO_DEPENDS.

To do this, you should set the DEPENDS argument of qi_stage_lib, like this:

qi_stage_lib(foo DEPENDS "BOOST_CHRONO;BOOST_SYSTEM")

Of course, this also means you should not create any install rule for bar headers. Also, if the bar library is static, you can use qi_create_lib(bar NO_INSTALL) to make sure the bar library is not installed.

Using qi_stage_lib with INCLUDE_DIRS

This can happen for instance if you generate some headers at compile time, like this:

// -- in foo/config.in.hpp

// Configured by cmake
#cmakedefine SPAM

// -- in foo/foo.hpp
#include <foo/config.hpp>

# Generate a header at configuration time, in the build directory:
configure_file(config.in.hpp ${CMAKE_CURRENT_BINARY_DIR}/foo/config.hpp)

# Make sure the generated header can be found:
include_directories(${CMAKE_CURRENT_BINARY_DIR})

include_directories(".")

qi_create_lib(foo foo/foo.cpp foo/foo.hpp)

qi_stage_lib(foo
  INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR}
               ${CMAKE_CURRENT_SOURCE_DIR}
)

From an other project, you may have a file looking like

# include <foo/foo.hpp>

...

So here to find foo/foo.hpp when using the project foo from sources, you need to find /path/to/foo/src/libfoo/ and /path/to/foo/build/, because of the path where foo/config.hpp has been generated.

Note that you have to use absolute paths here, like any other cmake code generated to be use from sources.

Using qi_stage_lib with PATH_SUFFIXES

Contrary to the previous section, this is useful when you want to use foo from an installed package.

So let’s assume your CMake looks like this:

qi_create_lib(foo foo/foo.hpp foo/foo.cpp)

qi_install_header(foo/foo.hpp)

qi_stage_lib(foo)

As explained in the How to write a library section, you have chosen to have the foo.hpp header inside a nice foo/ subdirectory.

But let’s assume some other project uses #include <foo.hpp> directly.

They may not be willing to change their code just yet, but still be willing to use the qibuild cmake framework.

You have several solutions here:

• Install a foo.hpp in <prefix>/include/foo.hpp looking like

#warning "Please include foo/foo.hpp instead of foo.hpp"
#include <foo/foo.hpp>

• Use the PATH_SUFFIXES argument like this

qi_stage_lib(foo PATH_SUFFIXES foo)

Note that you have to use relative paths here, like any other cmake code that will end up being installed.