# Staging targets ¶

This module make libraries and executables build in this projects available to others projects.



qi_stage_lib(target [DEPRECATED <deprecated> ...]
[DEPENDS <depends> ...]
[INCLUDE_DIRS <include_dirs> ...]
[PATH_SUFFIXES <path_suffixes> ...]
)


 Arguments: target – a target created with qi_create_lib DEPRECATED – specify a deprecated message. This message will be displayed each time another project use that lib. DEPENDS – if not given, ${TARGET}_DEPENDS will be guessed from the previous calls to qi_use_lib(). Use this (with care!) to override this behavior. One should list all the (public) “direct” dependencies and their (public) dependencies. INCLUDE_DIRS – if not given,${TARGET}_INCLUDE_DIRS will be guessed from the previous calls to include_directories() Use this (with care!) to override this behavior. PATH_SUFFIXES – when your header is installed in foo/bar.h, but you still need to do #include , you can set PATH_SUFFIXES to ‘foo’. Be careful to test the install rules of your headers if you choose to do so.

Generate a ‘name’-config.cmake, allowing other project to find the library. Usage of the various arguments are a bit tricky, so please read Using qi_stage_lib before using them



[DEPENDS <depends> ...]
[INCLUDE_DIRS <include_dirs> ...]
[PATH_SUFFIXES <path_suffixes> ...]
)


 Arguments: name – the name of the library, clients of the library can use  qi_use_lib(... NAME)  DEPRECATED – specify a deprecated message. This message will be displayed each time another project use that lib. DEPENDS – if not given, ${NAME}_DEPENDS will be empty the previous calls to qi_use_lib(). INCLUDE_DIRS – if not given,${NAME}_INCLUDE_DIRS will be guessed from the previous calls to include_directories() Use this (with care!) to override this behavior. PATH_SUFFIXES – when your header is installed in foo/bar.h, but you still need to do #include , you can set PATH_SUFFIXES to ‘foo’. Be careful to test the install rules of your headers if you choose to do so.

Generate a ‘name’-config.cmake, allowing other projects to find the header-only library. If the library has some dependencies, use something like:



find_package(FOO)
include_directories(${FOO_INCLUDE_DIRS}) qi_stage_header_only_lib(bar DEPENDS FOO)   qi_stage_bin(target)   Arguments: target – the name of a target Generate a ‘name’-config.cmake, allowing other projects to find the binary Example  # in foo/CMakeLists.txt qi_create_bin(foo foo.cpp) qi_stage_bin(foo) # in bar/CMakeLists.txt: find_package(foo) # Do something with${FOO_EXECUTABLE}




qi_stage_cmake(module)


 Arguments: module – path to the module file, relative to CMAKE_CURRENT_SOURCE_DIR

stage a cmake file For instance, assuming you have a foo-config.cmake file containing my_awesome_function, you can do:



qi_stage_cmake("foo-config.cmake")



Then later, (in an other project, or in the same project):



find_package(foo)
my_awesome_function()




qi_stage_script(file_name [TRAMPOLINE]
[PYTHON]
[DEPENDS <depends> ...]
)


 Arguments: file_name – Path to the script in source dir. TRAMPOLINE – If set, will generate a trampoline script in sdk binary dir. Use this flag if your script uses any element that is built. PYTHON – set if script is written in python DEPENDS – list of target or packages this script depends on. Used for trampoline script generation only.

Stage an executable script

Will stage a cmake file so that others can locate the script. Use like this:



qi_stage_script(src/myscript)



And in other projects:



find_package(myscript)
use_script_in_function(\${MYSCRIPT_EXECUTABLE})




qi_use_lib(name [<remaining args> ...]
[ASSUME_SYSTEM_INCLUDE]
)


 Arguments: name – The target to add dependencies to. args ( remaining ) – dependencies ASSUME_SYSTEM_INCLUDE – Use  -isystem  for including dependencies. Useful for instance to ignore warnings coming from 3rd party headers.

Handles dependencies between projects.

Call find_package for you, then do all the include_directories and target_link_libraries that are needed.

Note

The name must be an existing target, so you must call  qi_use_lib  after  qi_create_bin  or  qi_create_lib 

You can however call  qi_use_lib  several times, for instance:



qi_create_bin(foo)

# ...

qi_use_lib(foo bar)
if(UNIX)
endif()




qi_stage_dir(directory)


 Arguments: directory – (optional): the directory to register, relative to CMAKE_CURRENT_SOURCE_DIR. Defaults to CMAKE_CURRENT_SOURCE_DIR Make sure configuration and data files in the given directory can be found by  qi::findData()  in this project or any dependency

For this to work, configuration files should be in  etc  and data files in  share 

Note that this function does not create any install rule, so you should call qi_install_data(share/... ) for the files to be found after your project is installed.




 Arguments: path – : the path to the pre-compiled SDK

Register the given path as a CMAKE_PREFIX_PATH.

Used when pre-compiled binaries are put under version control.

Note that the pre-compiled SDK must have the following layout:



lib
libfoo.so
include
foo
foo.h
share
cmake
foo
foo-config.cmake