torstenandCopilot
342ffd3e5c
- HandlerMinelayerData: BUILD_RTI Guards für RTI-Abhängigkeiten - svcTabCommon: Export-Header-Fix via Fallback-Target - TrainingAreaBase: Stub-Header für BUILD_RTI=OFF - ddsfts: Include-Pfad und Dependency-Fixes - BUILD_RTI=OFF Compilation vollständig unterstützt Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> Entire-Checkpoint: 01M0JNZA586SACX1PRZ2DJAE5S
566 lines
16 KiB
CMake
566 lines
16 KiB
CMake
# (c) 2017 Copyright, Real-Time Innovations, Inc. All rights reserved.
|
|
# No duplications, whole or partial, manual or electronic, may be made
|
|
# without express written permission. Any such copies, or revisions thereof,
|
|
# must display this notice unaltered.
|
|
# This code contains trade secrets of Real-Time Innovations, Inc.
|
|
|
|
#[[.rst:
|
|
.. connextdds_add_example:
|
|
|
|
ConnextDdsAddExample
|
|
--------------------
|
|
|
|
Function to build the examples.
|
|
|
|
::
|
|
|
|
connextdds_add_example(
|
|
IDL name
|
|
LANG language
|
|
[PREFIX prefix]
|
|
[SUB_NAME sub_name]
|
|
[PUB_NAME pub_name]
|
|
[DISABLE_SUBSCRIBER]
|
|
[NO_REQUIRE_QOS]
|
|
[DEPENDENCIES ...]
|
|
[CODEGEN_ARGS ...]
|
|
)
|
|
|
|
Add a new example to be built. This method will call Codegen, create the
|
|
CMake targets and set the dependencies.
|
|
|
|
``IDL`` (required):
|
|
Name of the IDL file (without extension).
|
|
``LANG`` (required):
|
|
Example language. Valid values are ``C``, ``C++``, ``C++98``, ``C++03`` and
|
|
``C++11``.
|
|
``PREFIX``:
|
|
Prefix name for the targets. If not present, the folder of the example name
|
|
will be used as prefix.
|
|
``SUB_NAME``:
|
|
Suffix for the subscriber application. If not present it's "subscriber".
|
|
``PUB_NAME``:
|
|
Suffix for the publisher application. If not present it's "publisher".
|
|
``DISABLE_SUBSCRIBER``:
|
|
Disable the subscriber build. The target for the subcriber will not be
|
|
created.
|
|
``NO_REQUIRE_QOS``:
|
|
If present, the function will copy the USER_QOS_PROFILES.xml file from the
|
|
source directory to the binary directory.
|
|
``DEPENDENCIES``:
|
|
Other target dependencies.
|
|
``CODEGEN_ARGS``:
|
|
Extra arguments for Codegen.
|
|
|
|
Output targets:
|
|
``<prefix>_publisher_<lang>``
|
|
Target for the publisher application.
|
|
``<prefix>_subscriber_<lang>``
|
|
Target for the subscriber application.
|
|
``<prefix>_<lang>_sources``
|
|
Target to call Codegen to generate the source files for the types and the
|
|
publisher and the subscriber (if they were generated).
|
|
``<prefix>_<lang>_obj``
|
|
Target for the object library with all the objects created with the source
|
|
code for the types.
|
|
``<prefix>_<lang>_qos``
|
|
Target to copy the USER_QOS_PROFILES.xml (if exists).
|
|
|
|
|
|
connextdds_call_codegen
|
|
--------------------
|
|
|
|
Function to generate the source code from codegen.
|
|
|
|
::
|
|
|
|
connextdds_call_codegen(
|
|
(IDL name | TYPE_FILE type_file_path)
|
|
LANG language
|
|
[PREFIX prefix]
|
|
[CODEGEN_ARGS ...]
|
|
)
|
|
|
|
Add a new example to be built. This method will call Codegen, create the
|
|
CMake targets and set the dependencies.
|
|
|
|
``IDL`` or ``TYPE_FILE`` (required):
|
|
One of the legacy ``IDL`` or ``TYPE_FILE`` must be provided. The IDL
|
|
argument expects the an IDL file name without extension. The new
|
|
``TYPE_FILE`` is to the type file path (could be IDL, XML, ...).
|
|
``LANG`` (required):
|
|
Example language. Valid values are ``C``, ``C++``, ``C++03`` and ``C++11``.
|
|
``PREFIX``:
|
|
Prefix name for the targets. If not present, the folder of the example name
|
|
will be used as prefix.
|
|
``CODEGEN_ARGS``:
|
|
Extra arguments for Codegen.
|
|
|
|
|
|
connextdds_copy_qos_profile
|
|
---------------------------
|
|
|
|
Function to copy the USER_QOS_PROFILES.xml file.
|
|
|
|
::
|
|
|
|
connextdds_copy_qos_profile(
|
|
TARGET_PREFIX prefix
|
|
DEPENDANT_TARGET dependant_target
|
|
[FILENAME qos_filename]
|
|
)
|
|
|
|
Copy the QoS profile file. It will create the ``<prefix>_<lang>_qos``
|
|
target. It will make the given target dependant of the target for the QoS.
|
|
|
|
``TARGET_PREFIX (required)``:
|
|
Prefix name for the target.
|
|
``DEPENDANT_TARGET``:
|
|
This target will depends of the created QoS target. So, when the dependant
|
|
target is build, the QoS file will be copied.
|
|
``FILENAME``:
|
|
The filename of the QoS file to be copied. If not specified the default
|
|
name USER_QOS_PROFILES.xml will be used.
|
|
|
|
connextdds_add_application
|
|
--------------------------
|
|
|
|
Function to build an example.
|
|
|
|
::
|
|
|
|
connextdds_add_application(
|
|
TARGET target
|
|
LANG language
|
|
SOURCES ...
|
|
[PREFIX prefix]
|
|
[OUTPUT_NAME output_name]
|
|
[QOS_FILENAME]
|
|
[NO_REQUIRE_QOS]
|
|
[DEPENDENCIES ...]
|
|
)
|
|
|
|
This method will create the executables from chosen sources.
|
|
|
|
``TARGET`` (required):
|
|
Name of the target for the application.
|
|
``LANG`` (required):
|
|
Example language. Valid values are ``C``, ``C++``, ``C++03`` and ``C++11``.
|
|
``PREFIX``:
|
|
Prefix name for the targets. If not present, the folder of the example name
|
|
will be used as prefix.
|
|
``OUTPUT_NAME``:
|
|
Output name for the application. If not present, the target name will be
|
|
used.
|
|
``QOS_FILENAME``:
|
|
The filename of the desired QOS file. If not specified USER_QOS_PROFILES.xml
|
|
is used.
|
|
``NO_REQUIRE_QOS``:
|
|
If present, the QoS file will not be copied to the binary dir.
|
|
``DEPENDENCIES``:
|
|
Other libraries to link.
|
|
|
|
#]]
|
|
|
|
include_guard(DIRECTORY)
|
|
|
|
# Find the RTI Connext DDS libraries
|
|
if(NOT RTIConnextDDS_FOUND)
|
|
find_package(RTIConnextDDS
|
|
"6.1.0"
|
|
REQUIRED
|
|
COMPONENTS
|
|
core
|
|
)
|
|
endif()
|
|
|
|
include(CMakeParseArguments)
|
|
include(ConnextDdsArgumentChecks)
|
|
include(ConnextDdsCodegen)
|
|
|
|
|
|
function(connextdds_add_example)
|
|
set(optional_args DISABLE_SUBSCRIBER NO_REQUIRE_QOS)
|
|
set(single_value_args IDL LANG PREFIX SUB_NAME PUB_NAME)
|
|
set(multi_value_args CODEGEN_ARGS DEPENDENCIES)
|
|
cmake_parse_arguments(_CONNEXT
|
|
"${optional_args}"
|
|
"${single_value_args}"
|
|
"${multi_value_args}"
|
|
${ARGN}
|
|
)
|
|
connextdds_check_required_arguments(
|
|
_CONNEXT_IDL
|
|
_CONNEXT_LANG
|
|
)
|
|
|
|
# First, we call Codegen to generate the header and source files from the
|
|
# IDL
|
|
if(_CONNEXT_CODEGEN_ARGS)
|
|
set(codegen_args CODEGEN_ARGS ${_CONNEXT_CODEGEN_ARGS})
|
|
else()
|
|
set(codegen_args)
|
|
endif()
|
|
|
|
if(_CONNEXT_PREFIX)
|
|
set(prefix "${_CONNEXT_PREFIX}")
|
|
else()
|
|
# If no prefix was given, the name of the example folder name is used
|
|
# as prefix
|
|
get_filename_component(
|
|
folder_name
|
|
"${CMAKE_CURRENT_SOURCE_DIR}"
|
|
DIRECTORY)
|
|
get_filename_component(
|
|
folder_name
|
|
"${folder_name}"
|
|
NAME)
|
|
set(prefix "${folder_name}")
|
|
endif()
|
|
|
|
set(sub_name "subscriber")
|
|
if (_CONNEXT_SUB_NAME)
|
|
set(sub_name "${_CONNEXT_SUB_NAME}")
|
|
endif()
|
|
|
|
set(pub_name "publisher")
|
|
if (_CONNEXT_PUB_NAME)
|
|
set(pub_name "${_CONNEXT_PUB_NAME}")
|
|
endif()
|
|
|
|
# Generate the sources for the types
|
|
connextdds_call_codegen(
|
|
IDL "${_CONNEXT_IDL}"
|
|
LANG "${_CONNEXT_LANG}"
|
|
PREFIX "${prefix}"
|
|
${codegen_args}
|
|
)
|
|
|
|
# Copy the USER_QOS_PROFILES.xml file if required
|
|
if(_CONNEXT_NO_REQUIRE_QOS)
|
|
set(no_require_qos NO_REQUIRE_QOS)
|
|
else()
|
|
set(no_require_qos)
|
|
endif()
|
|
|
|
|
|
# If the GENERATE_EXAMPLE option was provided, Codegen will generate the
|
|
# source code for the publisher and the subscriber applications
|
|
# If we don't provide that parameter, we will use the source code provided
|
|
# in the repository for the publisher and the subscriber
|
|
connextdds_sanitize_language(LANG ${_CONNEXT_LANG} VAR lang_var)
|
|
if(GENERATE_EXAMPLE IN_LIST _CONNEXT_CODEGEN_ARGS)
|
|
set(publisher_src ${${_CONNEXT_IDL}_${lang_var}_PUBLISHER_SOURCE})
|
|
set(subscriber_src ${${_CONNEXT_IDL}_${lang_var}_SUBSCRIBER_SOURCE})
|
|
else()
|
|
set(ex "c")
|
|
if("${_CONNEXT_LANG}" STREQUAL "C++"
|
|
OR "${_CONNEXT_LANG}" STREQUAL "C++98"
|
|
OR "${_CONNEXT_LANG}" STREQUAL "C++03"
|
|
OR "${_CONNEXT_LANG}" STREQUAL "C++11"
|
|
)
|
|
set(ex "cxx")
|
|
endif()
|
|
|
|
set(publisher_src
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/${_CONNEXT_IDL}_${pub_name}.${ex}"
|
|
)
|
|
set(subscriber_src
|
|
"${CMAKE_CURRENT_SOURCE_DIR}/${_CONNEXT_IDL}_${sub_name}.${ex}"
|
|
)
|
|
endif()
|
|
|
|
# Add the target for the publisher application
|
|
connextdds_add_application(
|
|
TARGET "publisher"
|
|
LANG ${_CONNEXT_LANG}
|
|
SOURCES ${publisher_src}
|
|
PREFIX ${prefix}
|
|
OUTPUT_NAME "${_CONNEXT_IDL}_${pub_name}"
|
|
${no_require_qos}
|
|
SOURCES
|
|
$<TARGET_OBJECTS:${prefix}_${lang_var}_obj>
|
|
"${publisher_src}"
|
|
DEPENDENCIES
|
|
${_CONNEXT_DEPENDENCIES}
|
|
)
|
|
|
|
if(NOT _CONNEXT_DISABLE_SUBSCRIBER)
|
|
# Add the target for the subscriber application
|
|
connextdds_add_application(
|
|
TARGET "subscriber"
|
|
LANG ${_CONNEXT_LANG}
|
|
SOURCES ${subscriber_src}
|
|
PREFIX ${prefix}
|
|
OUTPUT_NAME "${_CONNEXT_IDL}_${sub_name}"
|
|
${no_require_qos}
|
|
SOURCES
|
|
$<TARGET_OBJECTS:${prefix}_${lang_var}_obj>
|
|
"${subscriber_src}"
|
|
DEPENDENCIES
|
|
${_CONNEXT_DEPENDENCIES}
|
|
)
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
function(connextdds_call_codegen)
|
|
set(optional_args)
|
|
set(single_value_args IDL TYPE_PATH LANG PREFIX)
|
|
set(multi_value_args CODEGEN_ARGS)
|
|
cmake_parse_arguments(_CONNEXT
|
|
"${optional_args}"
|
|
"${single_value_args}"
|
|
"${multi_value_args}"
|
|
${ARGN}
|
|
)
|
|
connextdds_check_required_arguments(
|
|
_CONNEXT_LANG
|
|
_CONNEXT_PREFIX
|
|
)
|
|
|
|
if(
|
|
(NOT DEFINED _CONNEXT_IDL AND NOT DEFINED _CONNEXT_TYPE_PATH)
|
|
OR (DEFINED _CONNEXT_IDL AND DEFINED _CONNEXT_TYPE_PATH)
|
|
)
|
|
message(
|
|
FATAL_ERROR "It is necessary to specify one (and only one) of IDL /"
|
|
" TYPE_PATH variables in the connextdds_call_codegen function"
|
|
)
|
|
endif()
|
|
|
|
set(_type_file_name "${_CONNEXT_IDL}")
|
|
set(_type_file_path "${CMAKE_CURRENT_SOURCE_DIR}/${_type_file_name}.idl")
|
|
if(_CONNEXT_TYPE_PATH)
|
|
get_filename_component(_type_file_name "${_CONNEXT_TYPE_PATH}" NAME_WE)
|
|
get_filename_component(_type_file_path "${_CONNEXT_TYPE_PATH}" REALPATH)
|
|
endif()
|
|
|
|
# Get the list of the source files to genrate and configure the command
|
|
# to cal Codegen
|
|
connextdds_rtiddsgen_run(
|
|
IDL_FILE
|
|
"${_type_file_path}"
|
|
OUTPUT_DIRECTORY
|
|
"${CMAKE_CURRENT_BINARY_DIR}/src"
|
|
LANG ${_CONNEXT_LANG}
|
|
${_CONNEXT_CODEGEN_ARGS}
|
|
)
|
|
|
|
# Get the path to the generated publisher and subscriber source code
|
|
connextdds_sanitize_language(LANG ${_CONNEXT_LANG} VAR lang_var)
|
|
set(${_type_file_name}_${lang_var}_PUBLISHER_SOURCE
|
|
"${${_type_file_name}_${lang_var}_PUBLISHER_SOURCE}"
|
|
PARENT_SCOPE
|
|
)
|
|
set(${_type_file_name}_${lang_var}_SUBSCRIBER_SOURCE
|
|
"${${_type_file_name}_${lang_var}_SUBSCRIBER_SOURCE}"
|
|
PARENT_SCOPE
|
|
)
|
|
|
|
# This will help to ensure that all the files generated by codegen are
|
|
# created
|
|
add_custom_target(${_CONNEXT_PREFIX}_${lang_var}_sources
|
|
DEPENDS
|
|
${${_type_file_name}_${lang_var}_GENERATED_SOURCES}
|
|
)
|
|
|
|
# If we don't use a object library to generate our publisher and subsciber
|
|
# applications and we are building using more than one job, could happen
|
|
# the following situation:
|
|
# 1. The publisher and subscriber applications will be build in two
|
|
# different jobs (A and B)
|
|
# 2. The source code for the types is not generated
|
|
# 3. The job A will call Codegen
|
|
# 4. The job A starts to build the application
|
|
# 4. The job B calls Codegen
|
|
# 5. The build performer by the job A is broken because the job B is
|
|
# replacing code generated by the job A.
|
|
# Using the object library, we can depend of it and call the Codegen only
|
|
# one time.
|
|
set(obj_library ${_CONNEXT_PREFIX}_${lang_var}_obj)
|
|
add_library(${obj_library}
|
|
OBJECT
|
|
${${_type_file_name}_${lang_var}_SOURCES}
|
|
)
|
|
|
|
set(api "c")
|
|
set(c_standard C_STANDARD 90)
|
|
set(cxx_standard CXX_STANDARD 98)
|
|
if("${_CONNEXT_LANG}" STREQUAL "C++"
|
|
OR "${_CONNEXT_LANG}" STREQUAL "C++98"
|
|
)
|
|
set(api "cpp")
|
|
elseif("${_CONNEXT_LANG}" STREQUAL "C++03")
|
|
set(api "cpp2")
|
|
elseif("${_CONNEXT_LANG}" STREQUAL "C++11")
|
|
set(api "cpp2")
|
|
set(cxx_standard CXX_STANDARD 11)
|
|
endif()
|
|
|
|
target_compile_definitions(
|
|
${obj_library}
|
|
PRIVATE
|
|
$<TARGET_PROPERTY:RTIConnextDDS::${api}_api,INTERFACE_COMPILE_DEFINITIONS>)
|
|
|
|
target_include_directories(
|
|
${obj_library}
|
|
PRIVATE
|
|
$<TARGET_PROPERTY:RTIConnextDDS::${api}_api,INTERFACE_INCLUDE_DIRECTORIES>)
|
|
|
|
set_target_properties(
|
|
${obj_library}
|
|
PROPERTIES
|
|
${c_standard}
|
|
${cxx_standard}
|
|
)
|
|
|
|
add_dependencies(${obj_library}
|
|
${_CONNEXT_PREFIX}_${lang_var}_sources
|
|
)
|
|
|
|
endfunction()
|
|
|
|
|
|
function(connextdds_copy_qos_profile)
|
|
set(optional_args)
|
|
set(single_value_args TARGET_PREFIX DEPENDANT_TARGET FILENAME)
|
|
set(multi_value_args)
|
|
|
|
cmake_parse_arguments(_EXAMPLE_QOS
|
|
"${optional_args}"
|
|
"${single_value_args}"
|
|
"${multi_value_args}"
|
|
${ARGN}
|
|
)
|
|
|
|
if(_EXAMPLE_QOS_FILENAME)
|
|
set(user_qos_profile_name ${_EXAMPLE_QOS_FILENAME})
|
|
else()
|
|
set(user_qos_profile_name "USER_QOS_PROFILES.xml")
|
|
endif()
|
|
|
|
set(qos_file "${CMAKE_CURRENT_SOURCE_DIR}/${user_qos_profile_name}")
|
|
|
|
if(NOT EXISTS ${qos_file})
|
|
get_filename_component(user_qos_profile_directory "${qos_file}" DIRECTORY)
|
|
message(
|
|
FATAL_ERROR "The ${user_qos_profile_name} was not found in"
|
|
" ${user_qos_profile_directory}"
|
|
)
|
|
endif()
|
|
|
|
set(output_qos "${CMAKE_CURRENT_BINARY_DIR}/${user_qos_profile_name}")
|
|
|
|
set(target_qos "${_EXAMPLE_QOS_TARGET_PREFIX}qos")
|
|
|
|
if(NOT TARGET ${target_qos})
|
|
# We created a target and it depends of the output file
|
|
add_custom_target(${target_qos}
|
|
DEPENDS
|
|
${output_qos}
|
|
)
|
|
|
|
# Add the command to copy the USER_QOS_PROFILES.xml
|
|
add_custom_command(
|
|
OUTPUT
|
|
${output_qos}
|
|
COMMAND
|
|
${CMAKE_COMMAND} -E copy_if_different
|
|
${qos_file}
|
|
"${CMAKE_CURRENT_BINARY_DIR}"
|
|
COMMENT "Copying ${user_qos_profile_name}"
|
|
DEPENDS
|
|
${qos_file}
|
|
VERBATIM
|
|
)
|
|
endif()
|
|
|
|
add_dependencies(${_EXAMPLE_QOS_DEPENDANT_TARGET}
|
|
${target_qos}
|
|
)
|
|
|
|
endfunction()
|
|
|
|
|
|
function(connextdds_add_application)
|
|
set(optional_args NO_REQUIRE_QOS)
|
|
set(single_value_args TARGET LANG PREFIX OUTPUT_NAME QOS_FILENAME)
|
|
set(multi_value_args SOURCES DEPENDENCIES)
|
|
|
|
cmake_parse_arguments(_CONNEXT
|
|
"${optional_args}"
|
|
"${single_value_args}"
|
|
"${multi_value_args}"
|
|
${ARGN}
|
|
)
|
|
connextdds_check_required_arguments(
|
|
_CONNEXT_TARGET
|
|
_CONNEXT_LANG
|
|
_CONNEXT_SOURCES
|
|
)
|
|
|
|
set(api "c")
|
|
set(c_standard C_STANDARD 90)
|
|
set(cxx_standard CXX_STANDARD 98)
|
|
if("${_CONNEXT_LANG}" STREQUAL "C++"
|
|
OR "${_CONNEXT_LANG}" STREQUAL "C++98"
|
|
)
|
|
set(api "cpp")
|
|
elseif("${_CONNEXT_LANG}" STREQUAL "C++03")
|
|
set(api "cpp2")
|
|
elseif("${_CONNEXT_LANG}" STREQUAL "C++11")
|
|
set(api "cpp2")
|
|
set(cxx_standard CXX_STANDARD 11)
|
|
endif()
|
|
|
|
if(_CONNEXT_PREFIX)
|
|
set(target_name "${_CONNEXT_PREFIX}_${_CONNEXT_TARGET}_${api}")
|
|
set(qos_target "${_CONNEXT_PREFIX}_qos_${api}")
|
|
set(qos_prefix "${_CONNEXT_PREFIX}_${api}")
|
|
else()
|
|
set(target_name "${_CONNEXT_TARGET}_${api}")
|
|
set(qos_target "qos_${api}")
|
|
set(qos_prefix "${api}")
|
|
endif()
|
|
|
|
# Create the target
|
|
add_executable(${target_name} ${_CONNEXT_SOURCES})
|
|
|
|
# Link all the dependencies and the RTI libraries for the API language
|
|
target_link_libraries(${target_name}
|
|
PRIVATE
|
|
${_CONNEXT_DEPENDENCIES}
|
|
RTIConnextDDS::${api}_api
|
|
)
|
|
|
|
# Add the include directories
|
|
target_include_directories(${target_name}
|
|
PRIVATE
|
|
"${CMAKE_CURRENT_BINARY_DIR}/src"
|
|
)
|
|
|
|
# Set output name for the binary
|
|
set_target_properties(${target_name}
|
|
PROPERTIES
|
|
OUTPUT_NAME "${_CONNEXT_OUTPUT_NAME}"
|
|
${c_standard}
|
|
${cxx_standard}
|
|
)
|
|
|
|
if(NOT _CONNEXT_NO_REQUIRE_QOS)
|
|
if (_CONNEXT_QOS_FILENAME)
|
|
connextdds_copy_qos_profile(
|
|
TARGET_PREFIX "${qos_prefix}_"
|
|
DEPENDANT_TARGET "${target_name}"
|
|
FILENAME ${_CONNEXT_QOS_FILENAME})
|
|
else()
|
|
connextdds_copy_qos_profile(
|
|
TARGET_PREFIX "${qos_prefix}_"
|
|
DEPENDANT_TARGET "${target_name}")
|
|
endif()
|
|
|
|
endif()
|
|
|
|
endfunction()
|