FindRTIConnextDDS.cmake

#.rst:
# (c) 2017 Copyright, Real-Time Innovations, Inc. All rights reserved.
#
# RTI grants Licensee a license to use, modify, compile, and create derivative
# works of the software solely for use with RTI Connext DDS.  Licensee may
# redistribute copies of the software provided that all such copies are
# subject to this license. The software is provided "as is", with no warranty
# of any type, including any warranty for fitness for any purpose. RTI is
# under no obligation to maintain or support the software.  RTI shall not be
# liable for any incidental or consequential damages arising out of the use or
# inability to use the software.
#
# FindRTIConnextDDS
# -----------------
#
# Find RTI Connext libraries.
#
# Components
# ^^^^^^^^^^
# This module sets variables for the following components that are part of RTI
# Connext:
# - core (default, always provided)
# - test
# - test_helpers
# - distributed_logger
# - messaging_api
# - routing_service
# - security_plugins
# - security_plugins_wolfssl
# - monitoring_libraries
# - nddstls
# - transport_tcp
# - transport_tls
# - transport_wan
# - recording_service
# - cloud_discovery_service
# - persistence_service
# - web_integration_service
# - low_bandwidth_plugins
# - rtizrtps
#
# Core is always selected, because the rest of components depend on it.
# However, the rest of components must be explicitly selected in the
# find_package invocation for this module to set variables for the different
# libraries associated with them.
#
# Also, the version consistency across all the requested components can be
# checked. If the version between the components missmatch,
# `RTIConnextDDS_FOUND` will be set to `FALSE`. This feature can be enabled
# setting `ENABLE_VERSION_CONSISTENCY_CHECK` to `TRUE`.
#
# Imported Targets
# ^^^^^^^^^^^^^^^^
# This module defines the following `IMPORTED` targets:
#
# - ``RTIConnextDDS::core``
#   The base nddscore library.
# - ``RTIConnextDDS::c_api``
#   The nddsc library if found (nddscore will be linked as part of this target).
# - ``RTIConnextDDS::cpp_api``
#   The nddscpp library if found (nddscore and nddsc will be linked as part of
#   this target).
# - ``RTIConnextDDS::cpp2_api``
#   The nddscpp2 library if found (nddscore and nddsc will be linked as part
#   of this target).
# - ``RTIConnextDDS::metp``
#   The METP library if found (nddsmetp).
# - ``RTIConnextDDS::rtixml2``
#   The RTI XML2 library if found (rtixml2).
# - ``RTIConnextDDS::apputils_c``.
#   The APP Utils C library (rtiapputils).
# - ``RTIConnextDDS::rtisqlite``.
#   The RTI SQLite library (rtisqlite).
# - ``RTIConnextDDS::test``.
#   The RTI Test Framework library (rtitest).
# - ``RTIConnextDDS::test_helpers``.
#   The RTI Test Framework helpers libraries (includes nddsctesthelpers,
#   rtitest, nddsc and nddscore)
# - ``RTIConnextDDS::distributed_logger_c``
#   The C API library for Distributed Logger if found (includes rtidlc,
#   nddscore, and nddsc).
# - ``RTIConnextDDS::distributed_logger_cpp``
#   The CPP API library for Distributed Logger if found (includes rtidlcpp,
#   rtidlc, nddscore, nddsc and nddscpp).
# - ``RTIConnextDDS::distributed_logger_cpp2``
#   The CPP2 API library for Distributed Logger if found (includes rtidlcpp2,
#   rtidlc, nddscore, nddsc and nddscpp2).
# - ``RTIConnextDDS::messaging_c_api``
#   The Request Reply C API library if found (rticonnextmsgc).
# - ``RTIConnextDDS::messaging_cpp_api``
#   The Request Reply CPP API library if found (rticonnextmsgcpp).
# - ``RTIConnextDDS::messaging_cpp2_api``
#   The Request Reply CPP2 API library if found (rticonnextmsgcpp2).
# - ``RTIConnextDDS::security_plugins``
#   The Security Plugins libraries if found (nddssecurity).
# - ``RTIConnextDDS::monitoring``
#   The Monitoring library if found.
# - ``RTIConnextDDS::nddstls``
#   The TLS library if found (nddstls).
# - ``RTIConnextDDS::transport_tcp``
#   The Transport TCP library if found (nddstransporttcp).
# - ``RTIConnextDDS::transport_tls``
#   The Transport TLS library if found (nddstransporttls).
# - ``RTIConnextDDS::transport_wan``
#   The Transport WAN library if found (nddstransportwan).
# - ``RTIConnextDDS::low_bandwidth_discovery_static``
#   The Discovery Static library for Low Bandwidth Plugins if found
#   (nddsdiscoverystatic).
# - ``RTIConnextDDS::low_bandwidth_edisc``
#   The edisc library for Low Bandwidth Plugins if found (rtilbedisc).
# - ``RTIConnextDDS::low_bandwidth_pdisc``
#   The pdisc library for Low Bandwidth Plugins if found (rtilbpdisc).
# - ``RTIConnextDDS::low_bandwidth_rtps``
#   The rtps library for Low Bandwidth Plugins if found (rtilbrtps).
# - ``RTIConnextDDS::low_bandwidth_sm``
#   The sm library for Low Bandwidth Plugins if found (rtilbsm).
# - ``RTIConnextDDS::low_bandwidth_st``
#   The st library for Low Bandwidth Plugins if found (rtilbst).
# - ``RTIConnextDDS::rtizrtps``
#   The rtizrtps library if found (rtizrtps).
# - ``RTIConnextDDS::routing_service_infrastructure``
#   The infrastructure library for Routing Service if found.
# - ``RTIConnextDDS::routing_service_c``
#   The C API library for Routing Service if found (includes rtiroutingservice,
#   rtirsinfrastructure, rtixml2 and rticonnextmsgc; also nddsmetp and
#   rticonnextmsgc if found).
# - ``RTIConnextDDS::routing_service``
#   The same as RTIConnextDDS::routing_service_c. Maintained for backward
#   compatibility.
# - ``RTIConnextDDS::routing_service_cpp``
#   The same as RTIConnextDDS::routing_service_c but adding the CPP libraries.
# - ``RTIConnextDDS::routing_service_cpp2``
#   The same as RTIConnextDDS::routing_service_c but adding the CPP2 libraries.
# - ``RTIConnextDDS::assign_transformation``
#   The assign transformation library if found (includes rtirsassigntransf and
#   rtiroutingservice).
# - ``RTIConnextDDS::recording_service``
#   The Recording Service library if found (includes rtirecordingservice,
#   rtiroutingservice, rtirsinfrastructure, nddscpp2, rtidlc, nddsmetp,
#   rticonnextmsgc and rtixml2).
# - ``RTIConnextDDS::cloud_discovery_service_c``
#   The Cloud Discovery Service library if found (includes
#   rticlouddiscoveryservice, rtiroutingservice, rtirsinfrastructure, nddscpp2,
#   rtidlc, nddsmetp, rticonnextmsgc and rtixml2).
# - ``RTIConnextDDS::cloud_discovery_service_cpp``
#   The same as RTIConnextDDS::cloud_discovery_service_c but adding the CPP
#   libraries.
# - ``RTIConnextDDS::persistence_service_c``
#   The C API for Persistence Service if found (includes rtipersistenceservice,
#   nddsc, nddscore, rtisqlite, also rtidlc if found).
# - ``RTIConnextDDS::web_integration_service_cpp2``
#   The CPP2 API for Web Integration Service if found (rtiwebintegrationservice,
#   nddscore, nddsc, nddscpp, nddscpp2, rtiapputilsc, rtisqlite if found).
# Result Variables
# ^^^^^^^^^^^^^^^^
# This module will set the following variables in your project:
#
# - ``CONNEXTDDS_COMPILE_DEFINITIONS``
#   RTI Connext Compiler definitions as a list.
# - ``CONNEXTDDS_DEFINITIONS``
#   RTI Connext Compiler definitions as a string (deprecated).
# - ``CONNEXTDDS_EXTERNAL_LIBS``
#   RTI Connext external dependencies.
# - ``CONNEXTDDS_INCLUDE_DIRS``
#   RTI Connext include directories.
# - ``CONNEXTDDS_DLL_EXPORT_MACRO``
#   Macros to compile against RTI Connext shared libraries on Windows.
# - ``RTICODEGEN_DIR``
#   Path to the directory where RTI Codegen is placed.
# - ``RTICODEGEN``
#   Path to the RTI Codegen executable.
# - ``RTICODEGEN_VERSION``
#   RTI Codegen version.
#
# This module will set the following variables for all the different libraries
# that are part of the components selected at configuration time.
#
# - ``<LIBRARY_NAME>_LIBRARIES_RELEASE_STATIC``
#   Release static libraries for <LIBRARY_NAME>.
#   (e.g., ``CONNEXTDDS_C_API_LIBRARIES_RELEASE_STATIC``).
# - ``<LIBRARY_NAME>_LIBRARIES_RELEASE_SHARED``
#   Release shared libraries for <LIBRARY_NAME>.
#   (e.g., ``CONNEXTDDS_C_API_LIBRARIES_RELEASE_SHARED``).
# - ``<LIBRARY_NAME>_LIBRARIES_DEBUG_STATIC``
#   Debug static libraries for <LIBRARY_NAME>.
#   (e.g., ``CONNEXTDDS_C_API_LIBRARIES_DEBUG_STATIC``).
# - ``<LIBRARY_NAME>_LIBRARIES_DEBUG_SHARED``
#   Debug shared libraries for <LIBRARY_NAME>.
#   (e.g., ``CONNEXTDDS_C_API_LIBRARIES_DEBUG_SHARED``).
# - ``<LIBRARY_NAME>_LIBRARIES``
#   Depending on the value of CMAKE_BUILD_TYPE and BUILD_SHARED_LIBS,
#   this variable will be set with the requested value.
#   (e.g., if ``CMAKE_BUILD_TYPE`` is ``Release`` and ``BUILD_SHARED_LIBS`` is
#   ``OFF``, will have the same value as
#   ``CONNEXTDDS_C_API_LIBRARIES_RELEASE_STATIC``).
#
#   Also, the ``<VAR>_FOUND`` variable is set for each one of the previous
#   variables.
#
# The list of libraries for each component is the following:
#
# - ``core`` component (always set by this module):
#   - ``CONNEXTDDS_C_API``
#     (e.g., ``CONNEXTDDS_C_API_LIBRARIES_RELEASE_STATIC``)
#   - ``CONNEXTDDS_CPP_API``
#     (e.g., ``CONNEXTDDS_CPP_API_LIBRARIES_RELEASE_STATIC``)
#   - ``CONNEXTDDS_CPP2_API``
#     (e.g., ``CONNEXTDDS_CPP2_API_LIBRARIES_RELEASE_STATIC``)
#   - ``METP``
#     (e.g., ``METP_LIBRARIES_RELEASE_STATIC``)
#   - ``RTIXML2``
#     (e.g., ``RTIXML2_LIBRARIES_RELEASE_STATIC``)
#   - ``RTIAPPUTILS_C``
#     (e.g., ``RTIAPPUTILS_C_LIBRARIES_RELEASE_STATIC``)
#   - ``RTISQLITE``
#     (e.g., ``RTISQLITE_LIBRARIES_RELEASE_STATIC``)
#
# - ``test`` component:
#   - ``RTITEST``
#     (e.g., ``RTITEST_LIBRARIES_RELEASE_STATIC``)
#
# - ``test_helpers`` component:
#   - ``NDDS_TEST_HELPERS``
#     (e.g., ``NDDS_TEST_HELPERS_LIBRARIES_RELEASE_STATIC``)
#
# - ``distributed_loger`` component:
#   - ``DISTRIBUTED_LOGGER_C``
#     (e.g., ``DISTRIBUTED_LOGGER_C_LIBRARIES_RELEASE_STATIC)
#   - ``DISTRIBUTED_LOGGER_CPP``
#     (e.g., ``DISTRIBUTED_LOGGER_CPP_LIBRARIES_RELEASE_STATIC)
#   - ``DISTRIBUTED_LOGGER_CPP2``
#     (e.g., ``DISTRIBUTED_LOGGER_CPP2_LIBRARIES_RELEASE_STATIC)
#
# - ``messaging_api`` component:
#   - ``MESSAGING_C``
#     (e.g., ``MESSAGING_C_API_LIBRARIES_RELEASE_STATIC``)
#   - ``MESSAGING_CPP``
#     (e.g., ``MESSAGING_CPP_API_LIBRARIES_RELEASE_STATIC``)
#   - ``MESSAGING_CPP2``
#     (e.g, ``MESSAGING_CPP2_API_LIBRARIES_RELEASE_STATIC``)
#
# - ``routing_service`` component:
#   - ``ROUTING_SERVICE_API``
#     (e.g., ``ROUTING_SERVICE_API_LIBRARIES_RELEASE_STATIC``)
#   - ``ROUTING_SERVICE_INFRASTRUCTURE``
#     (e.g., ``ROUTING_SERVICE_INFRASTRUCTURE_LIBRARIES_RELEASE_STATIC``)
#   - ``ASSIGN_TRANSFORMATION``
#     (e.g., ``ASSIGN_TRANSFORMATION_LIBRARIES_RELEASE_STATIC``)
#
# - ``security_plugins`` component:
#   - ``SECURITY_PLUGINS``
#     (e.g., ``SECURITY_PLUGINS_LIBRARIES_RELEASE_STATIC``)
#
# - ``monitoring_libraries`` component:
#   - ``MONITORING_LIBRARIES``
#     (e.g., ``MONITORING_LIBRARIES_RELEASE_STATIC``)
#
# - ``nddstls`` component:
#   - ``NDDSTLS``
#     (e.g., ``NDDSTLS_LIBRARIES_RELEASE_STATIC``)
#
# - ``transport_tcp`` component:
#   - ``TRANSPORT_TCP``
#     (e.g., ``TRANSPORT_TCP_LIBRARIES_RELEASE_STATIC``)
#
# - ``transport_tls`` component:
#   - ``TRANSPORT_TLS``
#     (e.g., ``TRANSPORT_TLS_LIBRARIES_RELEASE_STATIC``)
#
# - ``transport_wan`` component:
#   - ``TRANSPORT_WAN``
#     (e.g., ``TRANSPORT_WAN_LIBRARIES_RELEASE_STATIC``)
#
# - ``recording_service`` component:
#   - ``RECORDING_SERVICE_API``
#     (e.g., ``RECORDING_SERVICE_API_LIBRARIES_RELEASE_STATIC``)
#
# - ``cloud_discovery_service`` component:
#   - ``CLOUD_DISCOVERY_SERVICE_API_C``
#     (e.g., ``CLOUD_DISCOVERY_SERVICE_API_C_LIBRARIES_RELEASE_STATIC``)
#   - ``CLOUD_DISCOVERY_SERVICE_API_CPP``
#     (e.g., ``CLOUD_DISCOVERY_SERVICE_API_CPP_LIBRARIES_RELEASE_STATIC``)
#
# - ``persistence_service`` component:
#   - ``PERSISTENCE_SERVICE_API_C``
#     (e.g., ``PERSISTENCE_SERVICE_API_C_LIBRARIES_RELEASE_STATIC``)
#
# - ``web_integration_service`` component:
#   - ``WEB_INTEGRATION_SERVICE_API_CPP2``
#     (e.g., ``WEB_INTEGRATION_SERVICE_API_CPP2_LIBRARIES_RELEASE_STATIC``)
#
# - ``low_bandwidth_plugins`` component:
#   - ``LOW_BANDWIDTH_DISCOVERY_STATIC``
#     (e.g., ``LOW_BANDWIDTH_DISCOVERY_STATIC_LIBRARIES_RELEASE_STATIC``)
#   - ``LOW_BANDWIDTH_EDISC``
#     (e.g., ``LOW_BANDWIDTH_EDISC_LIBRARIES_RELEASE_STATIC``)
#   - ``LOW_BANDWIDTH_PDISC``
#     (e.g., ``LOW_BANDWIDTH_PDISC_LIBRARIES_RELEASE_STATIC``)
#   - ``LOW_BANDWIDTH_RTPS``
#     (e.g., ``LOW_BANDWIDTH_RTPS_LIBRARIES_RELEASE_STATIC``)
#   - ``LOW_BANDWIDTH_SM``
#     (e.g., ``LOW_BANDWIDTH_SM_LIBRARIES_RELEASE_STATIC``)
#   - ``LOW_BANDWIDTH_ST``
#     (e.g., ``LOW_BANDWIDTH_ST_LIBRARIES_RELEASE_STATIC``)
#
# - ``rtizrtps`` component:
#   - ``RTIZRTPS``
#     (e.g., ``RTIZRTPS_LIBRARIES_RELEASE_STATIC``)
#
# Also, the ``<VAR>_FOUND`` variable is set for each one of the previous
# variables (e.g., ``MONITORING_LIBRARIES_RELEASE_STATIC_FOUND`` and
# ``MONITORING_LIBRARIES_FOUND`` are set).
#
# If you are building a simple ConnextDDS application (you are only using
# the  core libraries), use the following variables:
#
#  - For a C application: CONNEXTDDS_C_API
#  - For a Traditional C++ application: CONNEXTDDS_CPP_API
#  - For a Modern C++ application: CONNEXTDDS_CPP2_API
#
# Lastly, if you want to use the security plugins (or any other component),
# add the appropriate variables to your CMake script.
#
# Hints
# ^^^^^
# If the find_package invocation specifies a version, this module will try
# to find your Connext installation in the default installation
# directories. Likewise, the module will try to guess the name of the
# architecture you are trying to build against, by looking for it under the
# rti_connext_dds-x.y.z/lib.
#
# However, in some cases you must provide the following hints by defining some
# variables in your cmake invocation:
#
# - If you don't specify a version or you have installed Connext in a
#   non-default location, you must set the ``CONNEXTDDS_DIR`` pointing to your
#   RTI Connext installation folder. For example:
#       cmake -DCONNEXTDDS_DIR=/home/rti/rti_connext_dds-x.y.z
#
# - If you have installed more than one architecture on your system (i.e., more
#   than one target rtipkg), you must set the ``CONNEXTDDS_ARCH`` to provide
#   the name of the architecture. For example:
#       cmake -DCONNEXTDDS_ARCH=x64Linux3gcc5.4.0
#
# - If you are building against the security_plugins component, this module
#   will try to find OpenSSL in your system using find_package(OpenSSL). If you
#   want to build against a specific installation of OpenSSL, you must set the
#   ``CONNEXTDDS_OPENSSL_DIR`` to provide this module with the path to your
#   installation of OpenSSL. This variable has to be populated with the OpenSSL
#   root directory, e.g.:
#   <CONNEXTDDS_DIR>/third_party/openssl-<version>/<architecture>/release/
#
#   Besides that, if you are building against the security_plugins component and
#   you want to ensure that you are using a specific OpenSSL version, you must
#   set the ``CONNEXTDDS_OPENSSL_VERSION`` so that it can be added to the
#   find_package(OpenSSL) invocation.
#
#   Likewise, if instead of security_plugins you use security_plugins_wolfssl,
#   you will use the variables ``CONNEXTDDS_WOLFSSL_DIR`` and
#   ``CONNEXTDDS_WOLFSSL_VERSION``
#
# - To control the Connext libraries build type you will need to use the
#   ``CONNEXT_LIBS_BUILD_TYPE`` CMake variable. By default the imported target
#   libraries will be provided with the build type in use (the ``Auto`` value).
#   If you want to force a specific build type (Release or Debug) of the Connext
#   libraries, you will have to set the ``CONNEXT_LIBS_BUILD_TYPE`` CMake
#   variable. Example:
#       cmake -DCONNEXT_LIBS_BUILD_TYPE=Release
#
#   Take into account that forcing Release or Debug libraries could result in
#   errors when building the opposite build type (e.g.: using
#   ``-DCONNEXT_LIBS_BUILD_TYPE=Release`` and building with
#   ``cmake --build . --config Debug``). Mixing Connext Release and Debug
#   libraries can result in build errors or application problems like
#   double-freeing memory (once for the Debug symbol and another for the
#   Release one).
#
# Note
# ^^^^
# Some flags related to the compiler, (such as -std=c++11, needed when linking
# against the CPP2 libraries) will not be provided by this script. These flags
# should be provided by the build system.
#
# Examples
# ^^^^^^^^
# Simple Connext application
# ::
#   cmake_minimum_required(VERSION 3.11)
#   project (example)
#   set(CMAKE_MODULE_PATH
#       ${CMAKE_MODULE_PATH}
#       "/home/rti/rti_connext_dds-6.0.0/resource/cmake")
#
#   find_package(RTIConnextDDS EXACT "6.0.0" REQUIRED)
#
#   set(SOURCES_PUB
#       "src/HelloWorld_publisher.c"
#       "src/HelloWorld.c"
#       "src/HelloWorldPlugin.c"
#       "src/HelloWorldSupport.c"
#   )
#
#   add_executable(HelloWorld_c_publisher ${SOURCES_PUB})
#   target_link_libraries(HelloWorld_c_publisher
#       PUBLIC
#           RTIConnextDDS::c_api
#   )
#
#
# Simple Routing Service adapter
# ::
#   cmake_minimum_required(VERSION 3.11)
#   project (example)
#   set(CMAKE_MODULE_PATH
#       ${CMAKE_MODULE_PATH}
#       "/home/rti/rti_connext_dds-6.0.0/resource/cmake")
#
#   find_package(RTIConnextDDS
#       EXACT "6.0.0"
#       REQUIRED
#       COMPONENTS
#           routing_service
#   )
#
#   set(LIBRARIES
#       ${ROUTING_SERVICE_API_LIBRARIES_RELEASE_STATIC}
#       ${CONNEXTDDS_EXTERNAL_LIBS}
#   )
#
#   set(SOURCES_LIB
#       "src/FileAdapter.c"
#       "src/LineConversion.c"
#       "src/osapi.c"
#   )
#
#   add_library(shapestransf ${SOURCES_LIB})
#   target_link_libraries(shapestransf
#       PUBLIC
#           RTIConnextDDS::routing_service
#   )
#
# Supported platforms
# ^^^^^^^^^^^^^^^^^^^
# Oficially, this FindPackage supports the following platforms listed in the
# RTI Connext Core Libraries Platform Notes:
#
# - Linux platforms: x64
# - Darwin platforms: macOS x64 (10.13-10.15, 11-13) and ARMv8 (11-13)
# - Windows platforms: x64, ARM64
# - QNX platforms (7.0 and 7.1): x64 and ARMv8
#
# Other platforms and architectures might work, but they are not oficially
# supported.
#
# Toolchain examples
# ^^^^^^^^^^^^^^^^^^
# In order to build against cross-compiled architectures a toolchain file is
# needed. This file will contain all the necessary information about the
# compiler and other utility paths. To use a toolchain file in the build the
# following variable must be provided in the command
# ::
#
#     cmake -DCMAKE_TOOLCHAIN_FILE=<toolchain_file_path>.cmake <source_dir>/
#
# QNX
# """
# ARMv8 QNX 7.1 gpp sample toolchain file
# ::
#
#     set(CMAKE_SYSTEM_NAME QNX)
#     set(CMAKE_SYSTEM_VERSION 7.1)
#     set(CMAKE_SYSTEM_PROCESSOR armv8)
#
#     set(tools_dir "$ENV{QNX_HOST}/usr/bin")
#     set(CMAKE_C_COMPILER "${tools_dir}/qcc")
#     set(CMAKE_CXX_COMPILER "${CMAKE_C_COMPILER}")
#     set(CMAKE_C_COMPILER_TARGET "8.3.0,gcc_ntoaarch64le_gpp")
#     set(CMAKE_CXX_COMPILER_TARGET "${CMAKE_C_COMPILER_TARGET}")
#     set(CMAKE_LINKER "${CMAKE_C_COMPILER}" CACHE PATH "")
#     set(CMAKE_AR "${tools_dir}/ntoaarch64-ar" CACHE PATH "")
#
#     set(PLATFORM_MODERN_CXX_STANDARD 11)
#     set(CMAKE_CXX_EXTENSIONS TRUE)
#
# Logging in versions lower than CMake 3.15
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# For versions lower than CMake 3.15, the ``CONNEXTDDS_LOG_LEVEL`` variable
# should be used to define logging levels lower than ``STATUS`` mode. All these
# modes will show messages of current level and higher. The following modes are
# available:
#
# - ``STATUS``
#   Default mode. This will olnly show messages with same or higher logging
#   level than CMake ``STATUS``.
# - ``VERBOSE``
#   This mode will show all messages from ``VERBOSE`` level and higher.
# - ``DEBUG``
#   This last mode will show messages from all previous levels and ``DEBUG``.

include(CMakeParseArguments)

# Starting wiht CMake 3.12, find_package function calls searches for prefixes
# specified by the <PackageName>_ROOT variable and its corresponding environment
# variable. The OLD behaviour is to ignore those kind of variables, so we set
# the policy to NEW.
if(POLICY CMP0074)
    cmake_policy(SET CMP0074 NEW)
endif()

# Starting with CMake 3.3, the support for the IN_LIST operator in the if block
# was added. The OLD behaviour is to ignore this operator, so we set the policy
# to NEW.
if(POLICY CMP0057)
    cmake_policy(SET CMP0057 NEW)
endif()

#####################################################################
# Global Variables                                                  #
#####################################################################

set(CONNEXT_LIBS_BUILD_TYPE_LIST "Release" "Debug" "Auto")
set(CONNEXT_LIBS_BUILD_TYPE "Auto" CACHE STRING
    "Connext imported target libraries build type to use"
)

if(CONNEXTDDS_IMPORTED_TARGETS_DEBUG)
    message(DEPRECATION
        "CONNEXTDDS_IMPORTED_TARGETS_DEBUG variable will be deprecated in the"
        " future. Set the CONNEXT_LIBS_BUILD_TYPE variable value to Debug"
        "to get the same behavior."
    )
    set(CONNEXT_LIBS_BUILD_TYPE "Debug")
endif()

if(NOT CONNEXT_LIBS_BUILD_TYPE IN_LIST CONNEXT_LIBS_BUILD_TYPE_LIST)
    message(FATAL_ERROR
        "Ensure the CONNEXT_LIBS_BUILD_TYPE value is one of Auto, Release or"
        " Debug without quotes"
    )
endif()

#####################################################################
# Logging Macros                                                    #
#####################################################################

# These two macros allow better code tracing with debug and verbose messages
# using new CMake 3.15 message types. If CMake 3.14 or lower is in use,
# default messages will be displayed starting with ``DEBUG`` or ``VERBOSE``
# instead.
#
# Arguments:
# - message: provides the text message
if("${CMAKE_MINOR_VERSION}" GREATER_EQUAL "15")
    macro(connextdds_log_verbose)
        message(VERBOSE "VERBOSE " ${ARGN})
    endmacro()

    macro(connextdds_log_debug)
        message(DEBUG "  DEBUG " ${ARGN})
    endmacro()
else()
    set(CONNEXTDDS_LOG_LEVEL_LIST "STATUS" "VERBOSE" "DEBUG")

    if(NOT CONNEXTDDS_LOG_LEVEL)
        set(CONNEXTDDS_LOG_LEVEL "STATUS")
    endif()

    if(NOT CONNEXTDDS_LOG_LEVEL IN_LIST CONNEXTDDS_LOG_LEVEL_LIST)
        string(REPLACE ";"
            " " LOG_LEVELS_STRING
            "${CONNEXTDDS_LOG_LEVEL_LIST}")
        message(FATAL_ERROR "Log level must be one of: ${LOG_LEVELS_STRING}. "
                "It's default value is STATUS.")
    endif()

    macro(connextdds_log_verbose)
        if("${CONNEXTDDS_LOG_LEVEL}" MATCHES "VERBOSE|DEBUG")
            message(STATUS "VERBOSE " ${ARGN})
        endif()
    endmacro()

    macro(connextdds_log_debug)
        if("${CONNEXTDDS_LOG_LEVEL}" STREQUAL "DEBUG")
            message(STATUS "  DEBUG " ${ARGN})
        endif()
    endmacro()
endif()

# This macro allow xml login with previous ``VERBOSE`` loger macros.
#
# Arguments:
# - XML_NAME: provides the name of the xml
# - XML: provides the xml contents
macro(connextdds_log_xml XML_NAME XML)
    string(REPLACE "\n"
        ";" lines
        ${XML})

    connextdds_log_verbose("~~~~~~~START ${XML_NAME}~~~~~~~")
    foreach(line ${lines})
        connextdds_log_verbose("\t${line}")
    endforeach()
    connextdds_log_verbose("~~~~~~~FINISH ${XML_NAME}~~~~~~~")
endmacro()

#####################################################################
# Preconditions Check                                               #
#####################################################################
#
# Find RTI Connext installation. We provide some hints that include the
# CONNEXTDDS_DIR variable, the $NDDSHOME environment variable, and the
# default installation directories.
if(NOT CONNEXTDDS_DIR)
    connextdds_log_verbose("CONNEXTDDS_DIR not specified")

    # Is a patch
    if(PACKAGE_FIND_VERSION_COUNT EQUAL 4)
        set(folder_version
            "${PACKAGE_FIND_VERSION_MAJOR}.${PACKAGE_FIND_VERSION_MINOR}.${PACKAGE_FIND_VERSION_PATCH}"
        )
        connextdds_log_debug("The required ConnextDDS version is a patch")
    else()
        set(folder_version ${RTIConnextDDS_FIND_VERSION})
    endif()
    connextdds_log_verbose("ConnextDDS version ${folder_version}")

    if(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
        set(connextdds_root_hints
            "$ENV{HOME}/rti_connext_dds-${folder_version}"
        )
        set(connextdds_root_paths
            "$ENV{HOME}/rti_connext_dds-*"
        )

    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
        set(connextdds_root_hints
            "C:/Program Files (x86)/rti_connext_dds-${folder_version}"
            "C:/Program Files/rti_connext_dds-${folder_version}"
            "C:/rti_connext_dds-${folder_version}"
        )
        set(connextdds_root_paths
            "C:/Program Files (x86)/rti_connext_dds-*"
            "C:/Program Files/rti_connext_dds-*"
            "C:/rti_connext_dds-*"
        )

    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
        set(connextdds_root_hints
            "/Applications/rti_connext_dds-${folder_version}"
        )
        set(connextdds_root_paths
            "/Applications/rti_connext_dds-*"
        )
    endif()

    file(GLOB connextdds_root_paths_expanded
        LIST_DIRECTORIES TRUE
        ${connextdds_root_paths}
    )

    connextdds_log_debug("Root hints: ${connextdds_root_hints}")
    connextdds_log_debug("Root paths: ${connextdds_root_paths_expanded}")
endif()

# We require having an rti_versions file under the installation directory
# as we will use it to verify that the version is appropriate.
find_path(CONNEXTDDS_DIR
    NAMES
        "rti_versions.xml"
    HINTS
        "${NDDSHOME}"
        ENV CONNEXTDDS_DIR
        ENV NDDSHOME
        # ``FindRTIConnextDDS.cmake`` is located under ``resources/cmake`` in
        # the ConnextDDS installation
        "${CMAKE_CURRENT_LIST_DIR}/../../"
        ${connextdds_root_hints}
    PATHS
        ${connextdds_root_paths_expanded}

)

if(NOT CONNEXTDDS_DIR)
    set(error
        "CONNEXTDDS_DIR not specified. Please set -DCONNEXTDDS_DIR= to "
        "your RTI Connext installation directory"
    )
    message(FATAL_ERROR ${error})
endif()

message(STATUS "RTI Connext installation directory: ${CONNEXTDDS_DIR}")

set(codegen_name "rtiddsgen")
if(WIN32)
    set(codegen_name "${codegen_name}.bat")
endif()
connextdds_log_debug("Codegen script ${codegen_name}")

find_path(RTICODEGEN_DIR
    NAME "${codegen_name}"
    HINTS
        "${CONNEXTDDS_DIR}/bin"
        ENV RTICODEGEN_DIR
)

if(NOT RTICODEGEN_DIR)
    set(warning
        "Codegen was not found. Please, check if rtiddsgen is under your "
        "NDDSHOME/bin directory or provide it to CMake using -DRTICODEGEN_DIR"
    )
    message(WARNING ${warning})
else()
    find_program(RTICODEGEN
        NAME
            "${codegen_name}"
        HINTS
            ${RTICODEGEN_DIR}
        DOC "Path to RTI Codegen"
    )

    # Execute RTI Code Generator to get the version
    connextdds_log_debug("Get the Codegen version: '${RTICODEGEN} -version'")
    execute_process(
        COMMAND
            ${RTICODEGEN} -version
        OUTPUT_VARIABLE codegen_version_string
    )
    # Sanitize Codegen output. When run for the first time, it shows some paths
    # and CMake doesn't like Windows paths
    string(REPLACE "\\" "/" codegen_version_string "${codegen_version_string}")
    connextdds_log_debug("Command output:")
    connextdds_log_debug("${codegen_version_string}")
    # Instead of searching for a version (also found in the NDDSHOME directory
    # showed by Codegen when run for the first time), try to match a safer
    # string and then select the matching group for the version
    string(REGEX MATCH
        "rtiddsgen version ([0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9]+)?)"
	    _ "${codegen_version_string}"
    )
    set(RTICODEGEN_VERSION "${CMAKE_MATCH_1}")
    connextdds_log_verbose("Codegen version: ${RTICODEGEN_VERSION}")
endif()

# Find RTI Connext architecture if CONNEXTDDS_ARCH is unset
if(NOT CONNEXTDDS_ARCH)
    connextdds_log_verbose("CONNEXTDDS_ARCH was not provided")
    # Guess the RTI Connext architecture

    if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
        string(REGEX REPLACE "^([0-9]+).*$" "\\1"
            major_version
            "${CMAKE_CXX_COMPILER_VERSION}"
        )
        set(version_compiler "${major_version}.0")
        connextdds_log_debug("Compiler version: ${version_compiler}")

        string(REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1"
            kernel_version "${CMAKE_SYSTEM_VERSION}")
        connextdds_log_debug("Kernel version: ${kernel_version}")

        if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64")
            set(guessed_architecture
                 "arm64Darwin${kernel_version}${version_compiler}"
            )
        else()
            set(guessed_architecture
                 "x64Darwin${kernel_version}${version_compiler}"
            )
        endif()

    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
        if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86")
            set(connextdds_host_arch "i86Win32")
        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "AMD64")
            set(connextdds_host_arch "x64Win64")
        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "ARM64")
            set(connextdds_host_arch "arm64Win64")

        else()
            message(FATAL_ERROR
                "${CMAKE_HOST_SYSTEM} is not supported as host architecture")
        endif()
        connextdds_log_debug("Host architecture: ${connextdds_host_arch}")

        string(REGEX MATCH "[0-9][0-9][0-9][0-9]"
             vs_year
             "${CMAKE_GENERATOR}"
        )
        connextdds_log_debug("Visual Studio year: ${vs_year}")
        set(guessed_architecture "${connextdds_host_arch}VS${vs_year}")
    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
        if(CMAKE_COMPILER_VERSION VERSION_EQUAL "4.6.3")
            set(kernel_version "3.x")
        else()
            string(REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "\\1"
                kernel_version
                "${CMAKE_SYSTEM_VERSION}"
            )
        endif()

        connextdds_log_debug("Kernel version: ${kernel_version}")

        if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64")
            set(connextdds_host_arch "x64Linux")

        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i686")
            set(connextdds_host_arch "i86Linux")
        endif()

        connextdds_log_debug("Host architecture: ${connextdds_host_arch}")
        set(guessed_architecture
            "${connextdds_host_arch}${kernel_version}gcc${CMAKE_C_COMPILER_VERSION}")
    endif()

    connextdds_log_verbose("Guessed RTI architecture: ${guessed_architecture}")

    if(DEFINED ENV{CONNEXTDDS_ARCH})
        file(TO_CMAKE_PATH "$ENV{CONNEXTDDS_ARCH}" CONNEXTDDS_ARCH)
    elseif(EXISTS "${CONNEXTDDS_DIR}/lib/${guessed_architecture}")
        set(CONNEXTDDS_ARCH "${guessed_architecture}")
        connextdds_log_debug("${CONNEXTDDS_DIR}/lib/${guessed_architecture} exists")
    else()
        # If CONNEXTDDS_ARCH is unspecified, the module tries uses the first
        # architecture installed by looking under $CONNEXTDDS_DIR/lib.
        file(GLOB architectures_installed
            RELATIVE "${CONNEXTDDS_DIR}/lib"
            "${CONNEXTDDS_DIR}/lib/*")

        foreach(architecture_name ${architectures_installed})
            if(architecture_name STREQUAL "java")
                # Because the lib folder contains both target libraries and
                # Java JAR files, here we exclude the "java" in our algorithm
                # to guess the appropriate CONNEXTDDS_ARCH variable.
                continue()
            elseif(NOT "${architecture_name}" MATCHES "^[A-Za-z0-9]")
                # Sometimes, some hidden or temporary folders/files are
                # created. We skip them
                continue()
            elseif("${architecture_name}" MATCHES ${CMAKE_HOST_SYSTEM_NAME})
                    if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
                        # Get the installed Darwin
                        set(CONNEXTDDS_ARCH "${architecture_name}")
                    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
                        if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86" AND
                                "${architecture_name}" MATCHES "Win32")
                            # Get the x86Win32 architecture
                            set(CONNEXTDDS_ARCH "${architecture_name}")
                        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "AMD64" AND
                                "${architecture_name}" MATCHES "x64Win64")
                            # Get the x64Win64 architecture
                            set(CONNEXTDDS_ARCH "${architecture_name}")
                        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "ARM64" AND
                                "${architecture_name}" MATCHES "arm64Win64")
                            # Get the arm64Win64 architecture
                            set(CONNEXTDDS_ARCH "${architecture_name}")
                        endif()
                    elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
                        if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i686" AND
                            "${architecture_name}" MATCHES "x86Linux")
                            # Get the x86Linux architecture
                            set(CONNEXTDDS_ARCH "${architecture_name}")

                        elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64" AND
                            "${architecture_name}" MATCHES "x64Linux")
                            # Get the x64Linux architecture
                            set(CONNEXTDDS_ARCH "${architecture_name}")
                        endif()
                    endif()
                endif()

            if(CONNEXTDDS_ARCH)
                break()
            endif()
        endforeach()

        if(NOT CONNEXTDDS_ARCH)
            message(WARNING
                "CONNEXTDDS_ARCH not specified. Please set "
                "-DCONNEXTDDS_ARCH= to specify your RTI Connext "
                " architecture")
        endif()
    endif()
endif()

message(STATUS "RTI Connext architecture: ${CONNEXTDDS_ARCH}")

#####################################################################
# Helper Functions                                                  #
#####################################################################

# Checks that a certain field associated with a component is installed under
# CONNEXTDDS_DIR and that its version is consistent with the version required
# for the rest of modules. If RTICONNEXTDDS_VERSION, the version variable, is
# specified, then it checks that the value is consistent. Otherwise,
# it sets the value of RTICONNEXTDDS_VERSION so that it can be checked in
# future calls of this function to validate that its value is consistent
# accross fields and components.
#
# At the end of the script CMake will check that RTICONNEXTDDS_VERSION is
# consistent with the version specified by the user in the find_package
# invocation, acording to the matching rules defined by CMake.
#
# Arguments:
# - field_name: provides the name of the xml tag to search.
# - rti_versions_file: contents of the rti_versions.xml file.
# - rti_architectures: list of architectures to search if present in the
#   rti_versions.xml file
# Returns:
# - A warning is shown and the `rtiversion_error` variable will be set if the
#   component field is not present in rti_versions.xml or the version does not
#   match RTICONNEXTDDS_VERSION.
function(connextdds_check_component_field_version
    field_name
    rti_versions_file
    rti_architectures)
    connextdds_log_debug("connextdds_check_component_field_version called")
    connextdds_log_debug(
        "====================================================================")
    connextdds_log_debug("\tfield_name: ${field_name}")
    connextdds_log_debug("\trti_architectures: [${${rti_architectures}}]")
    connextdds_log_verbose("Checking version for ${field_name}")

    # Get the component info
    set(field_section_regex "<${field_name}>.*</${field_name}>")
    string(REGEX MATCH ${field_section_regex} field_xml "${rti_versions_file}")

    connextdds_log_xml("Component info:" "${field_xml}")

    # Check all the architectures defined in the component
    foreach(architecture IN LISTS ${rti_architectures})
        # Ignore java fro routing_service_host
        if(architecture STREQUAL "java" AND
            field_name STREQUAL "routing_service_host")
            continue()
        endif()

        string(CONCAT field_arch_regex
            "<installation>[\n\r\t ]*"
            "<architecture>${architecture}.*</architecture>"
            "[\n\r\t ]*<version>[0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9]+)?"
            "</version>")
        string(REGEX MATCH ${field_arch_regex} field_arch "${field_xml}")
        if(field_arch)
            connextdds_log_xml("Field arch:" "${field_arch}")
            break()
        endif()
    endforeach()

    if(NOT field_arch)
        message(WARNING
            "${field_name} is not installed for ${CONNEXTDDS_ARCH} "
            "under ${CONNEXTDDS_DIR}")
        set(rtiversion_error TRUE PARENT_SCOPE)
    endif()

    # Get the <version> tag from the component
    set(field_version_regex
        "<version>[0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9]+(\\.[0-9]+)?)?</version>")
    string(REGEX MATCH ${field_version_regex} field_version "${field_arch}")
    connextdds_log_xml("Component version tag:" "${field_version}")

    if(NOT field_version)
        set(rtiversion_error TRUE PARENT_SCOPE)
        message(WARNING
            "The version tag was not extracted from ${field_name} and "
            "${CONNEXTDDS_ARCH} under ${CONNEXTDDS_DIR}")
        return()
    endif()

    # Extract the version string from the tag
    set(field_version_number_regex
        "[0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9]+(\\.[0-9]+)?)?")
    string(REGEX MATCH
        ${field_version_number_regex}
        field_version_number
        ${field_version})

    connextdds_log_xml("Component version:" "${field_version_number}")

    if(NOT field_version_number)
        set(rtiversion_error TRUE PARENT_SCOPE)
        message(WARNING
            "The version number was not extracted from ${field_name} and "
            "${CONNEXTDDS_ARCH} under ${CONNEXTDDS_DIR}")
        return()
    endif()

    if(NOT "${RTICONNEXTDDS_VERSION}" VERSION_EQUAL "${field_version_number}")
        # Otherwise, if the detected version is inconsistent with the previous
        # value of RTICONNEXTDDS_VERSION, we throw an error.
        set(warning
            "The version of ${field} is ${field_version_number}, which "
            "is incosistent with the expected version... "
            "${RTICONNEXTDDS_VERSION}")
        message(WARNING ${warning})
        set(rtiversion_error TRUE PARENT_SCOPE)
    else()
        connextdds_log_verbose("${field_name} version.........OK")
    endif()
    connextdds_log_debug(
        "====================================================================")
endfunction()

# This method searches the libraries indicated in `library_names` under
# `<RTI Connext directory>/lib/<architecture>. If one of the libraries in
# one of the modes is not found, the variable <result_var_name>_FOUND is set
# to `FALSE`.
#
# After finding the libraries, the libraries are stored in different variables
# following the structure <result_var_name>_<build_type>_<link_type>. Each
# variable contain the libraries for a build and link mode. If one of the
# libraries is not found, the <result_var_name>_<build_type>_<link_type>_FOUND
# is set to `FALSE`.
#
# Arguments:
# - library_names: names of the libraries to find (sorted)
# - result_var_name: name of the variable to set with the found libraries
# Returns:
# - <result_var_name>_RELEASE_STATIC: containing the release/static libraries
# - <result_var_name>_RELEASE_SHARED:  containing the release/shared libraries
# - <result_var_name>_DEBUG_STATIC:  containing the debug/static libraries
# - <result_var_name>_DEBUG_SHARED:  containing the debug/shared libraries
# - <result_var_name>_FOUND: `True` if all the libraries were found
function(get_all_library_variables
    library_names
    result_var_name)
    connextdds_log_debug("get_all_library_variables called")
    connextdds_log_debug(
        "====================================================================")
    connextdds_log_debug("\tlibrary_names: ${library_names}")
    connextdds_log_debug("\tresult_var_name: ${result_var_name}")

    set(mode_library_found TRUE)
    set(${result_var_name}_FOUND TRUE PARENT_SCOPE)

    foreach(build_mode "release" "debug")
        foreach(link_mode "static" "shared")
            set(libraries)
            foreach(library_name ${library_names})
                if(${link_mode} STREQUAL "static")
                    set(name "${library_name}z")
                else()
                    set(name "${library_name}")
                endif()

                if(${build_mode} STREQUAL "debug")
                    set(name "${name}d")
                else()
                    set(name "${name}")
                endif()
                connextdds_log_debug(
                    "\t\t[${build_mode}/${link_mode}]Library name: ${name}")

                find_library(lib${library_name}_${build_mode}_${link_mode}
                    NAMES
                        ${name}
                    PATHS
                        "${CONNEXTDDS_DIR}/lib/${CONNEXTDDS_ARCH}"
                    NO_DEFAULT_PATH
                    NO_CMAKE_PATH
                    NO_CMAKE_ENVIRONMENT_PATH
                    NO_SYSTEM_ENVIRONMENT_PATH
                    NO_CMAKE_SYSTEM_PATH
                )

                if(lib${library_name}_${build_mode}_${link_mode}-NOTFOUND)
                    set(mode_library_found FALSE)
                    break()
                else()
                    list(APPEND libraries
                        ${lib${library_name}_${build_mode}_${link_mode}})
                endif()
            endforeach()

            string(TOUPPER ${link_mode} upper_link_mode)
            string(TOUPPER ${build_mode} upper_build_mode)

            if(${mode_library_found})
                set(lib_var
                    "${result_var_name}_LIBRARIES_${upper_build_mode}_${upper_link_mode}"
                )
                set(${lib_var} ${libraries} PARENT_SCOPE)
                connextdds_log_debug("\t${lib_var} = ${libraries}")
                set(${lib_var}_FOUND TRUE PARENT_SCOPE)
            else()
                set(${lib_var}_FOUND FALSE PARENT_SCOPE)
                set(${result_var_name}_FOUND FALSE PARENT_SCOPE)
            endif()
            unset(lib${library_name}_${build_mode}_${link_mode} CACHE)
        endforeach()
    endforeach()

    if(CMAKE_BUILD_TYPE)
        string(TOUPPER "${CMAKE_BUILD_TYPE}" build_mode)
    else()
        set(build_mode "DEBUG")
    endif()

    if(${BUILD_SHARED_LIBS})
        set(link_mode "SHARED")
    else()
        set(link_mode "STATIC")
    endif()

    set(${result_var_name}_LIBRARIES
        ${result_var_name}_LIBRARIES_${build_mode}_${link_mode})
    connextdds_log_debug(
        "\t${result_var_name}_LIBRARIES=${${result_var_name}_LIBRARIES}"
    )
    connextdds_log_debug(
        "===================================================================="
    )
endfunction()

# This macro adds the location property to a list of properties in order to
# clean the ``create_connext_imported_target`` function.
# Arguments:
# - _list_var: List variable name to which to append the location properties.
# - _location_property_name: The name of the location property to append to the
#   list.
# - _library_var: Library path variable name.
macro(_append_location_property _list_var _location_property_name _library_var)
    list(GET ${_library_var} 0 _imported_library)
    connextdds_log_debug("\t${_location_property_name}=${_library_var}")
    connextdds_log_debug("\t\t${_imported_library}")
    list(APPEND ${_list_var} ${_location_property_name} "${_imported_library}")
    unset(_imported_library)
endmacro()

# This function helps to create a ConnextDDS CMake imported target.
# Arguments:
# - TARGET: the name of the target to be created. Note that the prefix
#   `RTIConnextDDS::` will be added.
# - VAR: name of the variable where the library and its dependencies were
#   stored. The library we want to use for the imported target must be at the
#   0 position. Note the dependencies included in this variable will not be
#   used for the creation of the imported target. The `DEPENDENCIES` argument
#   is for that purpose.
# - DEPENDENCIES: other imported targets or libraries that are dependencies.
# Returns:
# - A new target called `RTIConnextDDS::<TARGET>`, set to work properly with
#   the desired ConnextDDS library, using the DEPENDENCIES as interface
#   dependencies.
#   If the target was created previusly or the library was not found, nothing
#   will happen.
function(create_connext_imported_target)
    set(options "")
    set(single_value_args "TARGET" "VAR")
    set(multi_value_args "DEPENDENCIES")
    cmake_parse_arguments(_CONNEXT
        "${options}"
        "${single_value_args}"
        "${multi_value_args}"
        ${ARGN}
    )

    connextdds_log_debug("create_connext_imported_target called")
    connextdds_log_debug(
        "===================================================================="
    )

    if(WIN32
        AND NOT BUILD_SHARED_LIBS
        AND ${_CONNEXT_TARGET} STREQUAL "routing_service_c"
        AND RTICONNEXTDDS_VERSION VERSION_LESS "6.0.0"
    )
        # ROUTING-276: Routing Service is not available as a static library
        # for Windows until 6.0.0
        return()
    endif()

    set(target_name RTIConnextDDS::${_CONNEXT_TARGET})
    connextdds_log_debug("\ttarget_name=${target_name}")

    if(TARGET ${target_name})
        connextdds_log_debug("\tThe target already exists. Skipping...")
        connextdds_log_debug(
            "=================================================================="
            "=="
        )
        return() # Nothing to be done
    endif()

    if(NOT ${_CONNEXT_VAR}_FOUND)
        connextdds_log_debug(
            "\tNot every library configuration has been found. Skipping..."
        )
        connextdds_log_debug(
            "=================================================================="
            "=="
        )
        return() # Nothing to be done
    endif()

    set(imported_lib_base "${_CONNEXT_VAR}_LIBRARIES")

    # Set the build type to use
    if(BUILD_SHARED_LIBS)
        set(link_mode "SHARED")
        set(extra_options IMPORTED_NO_SONAME TRUE)
    else()
        set(link_mode "STATIC")
        set(extra_options)
    endif()

    # Define the location property to use
    if(WIN32 AND BUILD_SHARED_LIBS)
        set(location_property IMPORTED_IMPLIB)
    else()
        set(location_property IMPORTED_LOCATION)
    endif()

    set(import_location_properties)
    set(build_mode "RELEASE")
    if(CONNEXT_LIBS_BUILD_TYPE STREQUAL "Debug")
        set(build_mode "DEBUG")
    endif()

    _append_location_property(
        "import_location_properties"
        "${location_property}"
        "${imported_lib_base}_${build_mode}_${link_mode}"
    )

    if(CONNEXT_LIBS_BUILD_TYPE STREQUAL "Auto")
        foreach(build_mode "RELEASE" "DEBUG")
            _append_location_property(
                "import_location_properties"
                "${location_property}_${build_mode}"
                "${imported_lib_base}_${build_mode}_${link_mode}"
            )
        endforeach()
    endif()

    # Create the library
    add_library(${target_name} ${link_mode} IMPORTED)

    # Set properties for all the targets
    set_target_properties(${target_name}
        PROPERTIES
            ${import_location_properties}
            ${extra_options}
            MAP_IMPORTED_CONFIG_MINSIZEREL Release
            MAP_IMPORTED_CONFIG_RELWITHDEBINFO Release
    )

    # Add dependencies
    if(_CONNEXT_DEPENDENCIES)
        set_target_properties(${target_name}
            PROPERTIES
                INTERFACE_LINK_LIBRARIES
                   "${_CONNEXT_DEPENDENCIES}"
        )
    endif()

    connextdds_log_debug(
        "===================================================================="
    )
endfunction()

#####################################################################
# Get the version                                                   #
#####################################################################
# In the header files, there is a variable that contains the BUILD ID of the
# release. From the BUILD ID, we can get the version.
set(regex_for_build "NDDSCORE_BUILD_.*_RTI_.*")
file(STRINGS
    "${CONNEXTDDS_DIR}/include/ndds/core_version/core_version_buildid.h"
    build_id_line
    REGEX ${regex_for_build}
)
string(REGEX MATCH
    ${regex_for_build}
    CONNEXTDDS_BUILD_ID
    "${build_id_line}"
)
string(REGEX MATCH
   "[0-9]+\\.[0-9]+\\.[0-9]+(\\.[0-9]+)?"
    RTICONNEXTDDS_VERSION
    "${CONNEXTDDS_BUILD_ID}"
)

#####################################################################
# Platform-specific Definitions                                     #
#####################################################################

set(connextdds_host_arch "java")

if(CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
    if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "arm64")
        set(connextdds_host_arch ${connextdds_host_arch} "arm64Darwin")
    else()
        set(connextdds_host_arch ${connextdds_host_arch} "x64Darwin")
    endif()
elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
    if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86")
        set(connextdds_host_arch ${connextdds_host_arch} "i86Win32")
    elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "AMD64")
        set(connextdds_host_arch ${connextdds_host_arch} "x64Win64")
    elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "ARM64")
        set(connextdds_host_arch ${connextdds_host_arch} "arm64Win64")
    else()
        message(FATAL_ERROR
            "${CMAKE_HOST_SYSTEM} is not supported as host architecture"
        )
    endif()
elseif(CMAKE_HOST_SYSTEM_NAME MATCHES "Linux")
    if(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "x86_64")
        set(connextdds_host_arch ${connextdds_host_arch} "x64Linux")
    elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "i686")
        set(connextdds_host_arch ${connextdds_host_arch} "i86Linux")
    elseif(CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "aarch64")
        set(connextdds_host_arch
            ${connextdds_host_arch}
            "i86Linux"
            "x64Linux"
            "armv8"
        )
    else()
        message(FATAL_ERROR
            "${CMAKE_HOST_SYSTEM} is not supported as host architecture"
        )
    endif()
else()
    message(FATAL_ERROR
        "${CMAKE_HOST_SYSTEM} is not supported as host architecture")
endif()

if(CONNEXTDDS_ARCH MATCHES "Linux")
    # Linux Platforms
    set(CONNEXTDDS_EXTERNAL_LIBS
        "-ldl"
        "-lm"
        "-lpthread"
        "-lrt"
        "-rdynamic"
    )

    set(CONNEXTDDS_COMPILE_DEFINITIONS
        "RTI_UNIX"
        "RTI_LINUX"
    )

    if(CONNEXTDDS_ARCH MATCHES "x64Linux|armv8")
        list(APPEND CONNEXTDDS_COMPILE_DEFINITIONS
            "RTI_64BIT"
        )
    endif()

elseif(CONNEXTDDS_ARCH MATCHES "Win")
    # Windows Platforms
    set(CONNEXTDDS_EXTERNAL_LIBS
        "ws2_32"
        "netapi32"
        "version"
    )

    set(CONNEXTDDS_COMPILE_DEFINITIONS
        "WIN32_LEAN_AND_MEAN"
        "WIN32"
        "_WINDOWS"
        "RTI_WIN32"
        "_BIND_TO_CURRENT_MFC_VERSION=1"
        "_BIND_TO_CURRENT_CRT_VERSION=1"
        "_SCL_SECURE_NO_WARNINGS"
        "_CRT_SECURE_NO_WARNING"
    )

    if(BUILD_SHARED_LIBS)
        # When building against ConnextDDS's shared libraries, users need to also
        # add the CONNEXTDDS_DLL_EXPORT_MACRO to their definitions.
        set(CONNEXTDDS_DLL_EXPORT_MACRO "NDDS_DLL_VARIABLE")
    endif()

elseif(CONNEXTDDS_ARCH MATCHES "Darwin")
    # Darwin Platforms
    set(CONNEXTDDS_EXTERNAL_LIBS "")

    set(CONNEXTDDS_COMPILE_DEFINITIONS
        "RTI_UNIX"
        "RTI_DARWIN"
        "RTI_DARWIN20"
        "RTI_64BIT"
    )
elseif(CONNEXTDDS_ARCH MATCHES "QNX|QOS")
    set(CONNEXTDDS_EXTERNAL_LIBS
        "-lm"
        "-lsocket"
    )
    set(CONNEXTDDS_COMPILE_DEFINITIONS
        "RTI_QNX"
    )

    if(CONNEXTDDS_ARCH MATCHES "QNX7")
        list(APPEND CONNEXTDDS_COMPILE_DEFINITIONS "RTI_QNX7")
    endif()

    if(CONNEXTDDS_ARCH MATCHES "cxx")
        set(CONNEXTDDS_COMPILE_OPTIONS "-Y_cxx")
    elseif(CONNEXTDDS_ARCH MATCHES "gpp")
        set(CONNEXTDDS_COMPILE_OPTIONS "-Y_gpp")
    endif()

    if(CONNEXTDDS_ARCH MATCHES "armv8")
        list(APPEND CONNEXTDDS_COMPILE_OPTIONS "-Vgcc,gcc_ntoaarch64le")
    elseif(CONNEXTDDS_ARCH MATCHES "x64")
        list(APPEND CONNEXTDDS_COMPILE_OPTIONS "-Vgcc,gcc_ntox86_64")
    endif()
else()
    message(FATAL_ERROR
        "${CONNEXTDDS_ARCH} architecture is unsupported by this module"
    )
endif()

#####################################################################
# Core Component Variables                                          #
#####################################################################

# This script verifies the version of each of the following fields in
# ${CONNEXTDDS_DIR}/rti_versions.xml, as they are the basic components of the
# RTI Connext core libraries, which are always part of an installation.
list(APPEND rti_versions_field_names_host
    "header_files"
    "host_files"
    "core_release_docs"
    "core_api_docs"
    "core_jars"
)

list(APPEND rti_versions_field_names_target
    "target_libraries"
)

find_path(CONNEXTDDS_BASE_INCLUDE_DIRS
    NAMES
        "ndds_c.h"
    PATHS
        "${CONNEXTDDS_DIR}/include/ndds"
)

# Define CONNEXTDDS_INCLUDE_DIRS
set(CONNEXTDDS_INCLUDE_DIRS)

list(APPEND CONNEXTDDS_INCLUDE_DIRS
    "${CONNEXTDDS_DIR}/include"
    ${CONNEXTDDS_BASE_INCLUDE_DIRS}
    "${CONNEXTDDS_BASE_INCLUDE_DIRS}/hpp"
)

# Find all flavors of nddscore
get_all_library_variables("nddscore" "CONNEXTDDS_CORE")

# Find all flavors of nddsc and nddscore
set(c_api_libs
    "nddsc"
    "nddscore"
)
get_all_library_variables("${c_api_libs}" "CONNEXTDDS_C_API")

# Find all flavors of nddscpp and nddscore
set(cpp_api_libs
    "nddscpp"
    "nddsc"
    "nddscore"
)
get_all_library_variables("${cpp_api_libs}" "CONNEXTDDS_CPP_API")

# Find all flavors of nddscpp2 and nddscore
set(cpp2_api_libs
    "nddscpp2"
    "nddsc"
    "nddscore"
)
get_all_library_variables("${cpp2_api_libs}" "CONNEXTDDS_CPP2_API")

# Find all flavors of libnddsmetp
set(metp_libs
    "nddsmetp"
    "nddsc"
    "nddscore"
)
get_all_library_variables("${metp_libs}" "METP")

# Find all flavors of librtixml2
set(rtixml2_libs
    "rtixml2"
    "nddsc"
    "nddscore"
)
get_all_library_variables("${rtixml2_libs}" "RTIXML2")

# Find all flavors of librtiapputilsc
set(librtiapputilsc_libs
    "rtiapputilsc"
    "rtixml2"
    "nddsc"
    "nddscore"
)
get_all_library_variables("${librtiapputilsc_libs}" "RTIAPPUTILS_C")

# Find all flavors of rtisqlite
get_all_library_variables("rtisqlite" "RTISQLITE")

if(CONNEXTDDS_CORE_FOUND AND CONNEXTDDS_C_API_FOUND)
    set(RTIConnextDDS_core_FOUND TRUE)
else()
    set(RTIConnextDDS_core_FOUND FALSE)
endif()

#####################################################################
# RTI Test Framework Component Variables                            #
#####################################################################
if(test IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR test_helpers IN_LIST RTIConnextDDS_FIND_COMPONENTS
)
    # Find all flavors of rtitest
    set(rtitest_libs "rtitest")
    get_all_library_variables("${rtitest_libs}"
        "RTITEST"
    )

    set(RTIConnextDDS_test_FOUND FALSE)
    if(RTITEST_FOUND)
        if(WIN32 AND BUILD_SHARED_LIBS)
            list(APPEND CONNEXTDDS_DLL_EXPORT_MACRO "RTI_test_DLL_VARIABLE")
        endif()
        set(RTIConnextDDS_test_FOUND TRUE)
    endif()
endif()

#####################################################################
# RTI Test Framework Helpers Component Variables                    #
#####################################################################

if(test_helpers IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of test_helpers
    set(ndds_test_helpers_libs
        "nddsctesthelpers"
        "nddscore"
        "nddsc"
        "rtitest"
    )
    get_all_library_variables("${ndds_test_helpers_libs}"
        "NDDS_TEST_HELPERS"
    )

    set(RTIConnextDDS_test_helpers_FOUND FALSE)
    if(NDDS_TEST_HELPERS_FOUND)
        if(WIN32 AND BUILD_SHARED_LIBS)
            list(APPEND CONNEXTDDS_DLL_EXPORT_MACRO
                "RTI_transport_test_DLL_VARIABLE"
            )
        endif()
        set(RTIConnextDDS_test_helpers_FOUND TRUE)
    endif()
endif()

#####################################################################
# Distributed Logger Component Variables                            #
#####################################################################
# Routing Service depends on Distributed Logger. Both Recording Service and
# Cloud Discovery Service depend on Routing Service.
if(distributed_logger IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR cloud_discovery_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR routing_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR recording_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR persistence_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
)
    # Find all flavors of rtidlc
    set(distributed_logger_c_libs "rtidlc" "nddsc" "nddscore")
    get_all_library_variables("${distributed_logger_c_libs}"
        "DISTRIBUTED_LOGGER_C"
    )

    # Find all flavors of rtidlcpp
    set(distributed_logger_cpp_libs
        "rtidlcpp"
        "rtidlc"
        "nddscpp"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${distributed_logger_cpp_libs}"
        "DISTRIBUTED_LOGGER_CPP"
    )

    # Find all flavors of rtidlcpp2
    set(distributed_logger_cpp2_libs
        "rtidlcpp2"
        "rtidlc"
        "nddscpp2"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${distributed_logger_cpp2_libs}"
        "DISTRIBUTED_LOGGER_CPP2"
    )

    if(DISTRIBUTED_LOGGER_C_FOUND AND DISTRIBUTED_LOGGER_CPP_FOUND)
        set(RTIConnextDDS_distributed_logger_FOUND TRUE)

        if(CMAKE_SYSTEM_NAME MATCHES "Linux" AND
            CMAKE_COMPILER_VERSION VERSION_GREATER "4.6.0" AND
            RTICONNEXTDDS_VERSION VERSION_LESS "6.1.0"
        )
            set(CONNEXTDDS_EXTERNAL_LIBS
                "-Wl,--no-as-needed"
                ${CONNEXTDDS_EXTERNAL_LIBS}
            )
        endif()
    else()
        set(RTIConnextDDS_distributed_logger_FOUND FALSE)
    endif()

    # Since the modern C++ library is only available after 7.2.0
    if(RTICONNEXTDDS_VERSION VERSION_GREATER_EQUAL "7.2.0" AND NOT DISTRIBUTED_LOGGER_CPP2_FOUND)
        set(RTIConnextDDS_distributed_logger_FOUND FALSE)
    endif()
endif()

#####################################################################
# Messaging Component Variables                                     #
#####################################################################
# Routing Service depends on the Messaging API. Both Recording Service and
# Cloud Discovery Service depend on Routing Service.
if(messaging_api IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR cloud_discovery_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR routing_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR recording_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
)
    list(APPEND rti_versions_field_names_host
        "request_reply_host"
    )
    list(APPEND rti_versions_field_names_target
        "request_reply"
    )

    # Find all flavors of librticonnextmsgc
    set(messaging_c_api_libs "rticonnextmsgc" "nddsc" "nddscore")
    get_all_library_variables("${messaging_c_api_libs}" "MESSAGING_C_API")

    # Find all flavors of librticonnextmsgcpp
    set(messaging_cpp_api_libs "rticonnextmsgcpp" "nddscpp" "nddsc" "nddscore")
    get_all_library_variables("${messaging_cpp_api_libs}" "MESSAGING_CPP_API")

    # Find all flavors of librticonnextmsgcpp2
    set(messaging_cpp2_api_libs
        "rticonnextmsgcpp2"
        "nddscpp2"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${messaging_cpp2_api_libs}"
        "MESSAGING_CPP2_API"
    )

    if(MESSAGING_C_API_FOUND AND MESSAGING_CPP_API_FOUND AND
        MESSAGING_CPP2_API_FOUND
    )
        set(RTIConnextDDS_messaging_api_FOUND TRUE)
    else()
        set(RTIConnextDDS_messaging_api_FOUND FALSE)
    endif()
endif()

#####################################################################
# Routing Service Component Variables                               #
#####################################################################
# Recording Service and Cloud Discovery Service depend on Routing Service
if(routing_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR cloud_discovery_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
    OR recording_service IN_LIST RTIConnextDDS_FIND_COMPONENTS
)
    # Add fields associated with the routing_service component
    list(APPEND rti_versions_field_names_host
        "routing_service_host"
        "routing_service"
    )
    if(RTICONNEXTDDS_VERSION VERSION_GREATER 5.3.0.8)
        list(APPEND rti_versions_field_names_host
            "routing_service_sdk_jars"
        )
    endif()

    list(APPEND rti_versions_field_names_target
        "routing_service_sdk"
    )

    # Find all flavors of librtirsinfrastructure
    set(rtirsinfrastructure_libs
        "rtirsinfrastructure"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${rtirsinfrastructure_libs}"
        "ROUTING_SERVICE_INFRASTRUCTURE"
    )

    set(rtiserviceadmincpp_libs
        "rtiserviceadmincpp"
        "nddscpp2"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${rtiserviceadmincpp_libs}"
        "ROUTING_SERVICE_ADMIN"
    )

    set(addon_dependencies)
    if(METP_LIBRARIES)
        list(APPEND addon_dependencies "nddsmetp")
    endif()

    if(RTIXML2_LIBRARIES)
        list(APPEND addon_dependencies "rtixml2")
    endif()

    if(RTIAPPUTILS_C_LIBRARIES)
        list(APPEND addon_dependencies "apputils_c")
    endif()

    if(RTIConnextDDS_distributed_logger_FOUND)
        list(APPEND addon_dependencies "rtidlc")
    endif()

    # Find all flavors of librtiroutingservice
    set(routing_service_libs
        "rtiroutingservice"
        "rtirsinfrastructure"
        "rtiserviceadmincpp"
        ${addon_dependencies}
        "rticonnextmsgc"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${routing_service_libs}" "ROUTING_SERVICE_API")

    if(WIN32 AND ROUTING_SERVICE_API_RELEASE_STATIC AND
        ROUTING_SERVICE_API_DEBUG_STATIC AND
        RTICONNEXTDDS_VERSION VERSION_LESS "6.0.0")
        # ROUTING-276: Routing Service is not available as a static library
        # for Windows until 6.0.0
        set(ROUTING_SERVICE_API_FOUND TRUE)
    endif()

    # Find all flavors of librtirsassigntransf
    set(assign_transformation_libs
        "rtirsassigntransf"
        "rtiroutingservice"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${assign_transformation_libs}"
        "ASSIGN_TRANSFORMATION"
    )

    if(ROUTING_SERVICE_API_FOUND)
        set(RTIConnextDDS_routing_service_FOUND TRUE)
    else()
        set(RTIConnextDDS_routing_service_FOUND FALSE)
    endif()

endif()

#####################################################################
# Security Plugins Component Variables                              #
#####################################################################
if(security_plugins IN_LIST RTIConnextDDS_FIND_COMPONENTS
    AND security_plugins_wolfssl IN_LIST RTIConnextDDS_FIND_COMPONENTS
)
    message(FATAL_ERROR
        "Cannot use security plugins for OpenSSL and wolfSSL at the same time"
    )
endif()

if(security_plugins IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    list(APPEND rti_versions_field_names_host
        "secure_base"
        "secure_host"
    )

    list(APPEND rti_versions_field_names_target
        "secure_target_libraries"
    )

    # Find all flavors of libnddssecurity
    set(security_plugins_libs
        "nddssecurity"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${security_plugins_libs}"
        "SECURITY_PLUGINS"
    )

    if(SECURITY_PLUGINS_FOUND)
        if(DEFINED CONNEXTDDS_OPENSSL_DIR)
            set(OPENSSL_ROOT_DIR "${CONNEXTDDS_OPENSSL_DIR}")
        endif()
        find_package(OpenSSL ${CONNEXTDDS_OPENSSL_VERSION} REQUIRED)

        # Add OpenSSL include directories to the list of
        # CONNEXTDDS_INCLUDE_DIRS
        list(APPEND CONNEXTDDS_INCLUDE_DIRS
            "${OPENSSL_INCLUDE_DIR}"
        )

        # Add OpenSSL libraries to the list of CONNEXTDDS_EXTERNAL_LIBS
        list(APPEND CONNEXTDDS_EXTERNAL_LIBS
            ${OPENSSL_SSL_LIBRARY}
            ${OPENSSL_CRYPTO_LIBRARY}
        )

        set(RTIConnextDDS_security_plugins_FOUND TRUE)
    else()
        set(RTIConnextDDS_security_plugins_FOUND FALSE)
    endif()

endif()

# Find the Security Plugins - this is for the wolfSSL case.
if(security_plugins_wolfssl IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    list(APPEND rti_versions_field_names_host
        "secure_base"
        "secure_host_wolfssl"
    )

    list(APPEND rti_versions_field_names_target
        "secure_target_libraries_wolfssl"
    )

    # Find all flavors of libnddssecurity
    set(security_plugins_wolfssl_libs
        "nddssecurity"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${security_plugins_wolfssl_libs}"
        "SECURITY_PLUGINS"
    )

    if(SECURITY_PLUGINS_FOUND)
        if(DEFINED CONNEXTDDS_WOLFSSL_DIR)
            set(WolfSSL_ROOT "${CONNEXTDDS_WOLFSSL_DIR}")
        endif()
        find_package(WolfSSL ${CONNEXTDDS_WOLFSSL_VERSION} REQUIRED)

        # Add wolfSSL include directories to the list of CONNEXTDDS_INCLUDE_DIRS
        list(APPEND CONNEXTDDS_INCLUDE_DIRS
            "${wolfSSL_INCLUDE_DIRS}"
        )

        # Add wolfSSL libraries to the list of CONNEXTDDS_EXTERNAL_LIBS
        list(APPEND CONNEXTDDS_EXTERNAL_LIBS
            ${wolfSSL_LIBRARY}
        )

        set(RTIConnextDDS_security_plugins_wolfssl_FOUND TRUE)
    else()
        set(RTIConnextDDS_security_plugins_wolfssl_FOUND FALSE)
    endif()

endif()

#####################################################################
# Monitoring Liraries Component Variables                           #
#####################################################################
if(monitoring_libraries IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of librtimonitoring
    get_all_library_variables("rtimonitoring" "MONITORING")

    if(MONITORING_FOUND)
        if(CONNEXTDDS_ARCH MATCHES "Win")
            set(CONNEXTDDS_EXTERNAL_LIBS
                psapi
                ${CONNEXTDDS_EXTERNAL_LIBS}
            )
        endif()
        set(RTIConnextDDS_monitoring_libraries_FOUND TRUE)
    else()
        set(RTIConnextDDS_monitoring_libraries_FOUND FALSE)
    endif()
endif()

#####################################################################
# TLS Static Component Variables                                    #
#####################################################################
if(nddstls IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of libnddstls
    set(nddstls_libs
        "nddstls"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${nddstls_libs}" "NDDSTLS")

    if(NDDSTLS_FOUND)
        set(RTIConnextDDS_nddstls_FOUND TRUE)
    else()
        set(RTIConnextDDS_nddstls_FOUND FALSE)
    endif()
endif()

#####################################################################
# Transport TCP Library Component Variables                         #
#####################################################################
if(transport_tcp IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of libnddstransporttcp
    set(transport_tcp_libs
        "nddstransporttcp"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${transport_tcp_libs}" "TRANSPORT_TCP")

    if(TRANSPORT_TCP_FOUND)
        set(RTIConnextDDS_transport_tcp_FOUND TRUE)
    else()
        set(RTIConnextDDS_transport_tcp_FOUND FALSE)
    endif()
endif()

#####################################################################
# Transport TLS Library Component Variables                         #
#####################################################################
if(transport_tls IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of libnddstransporttls
    set(transport_tls_libs
        "nddstransporttls"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${transport_tls_libs}" "TRANSPORT_TLS")

    if(TRANSPORT_TLS_FOUND)
        set(RTIConnextDDS_transport_tls_FOUND TRUE)
    else()
        set(RTIConnextDDS_transport_tls_FOUND FALSE)
    endif()
endif()

#####################################################################
# Transport WAN Library Component Variables                         #
#####################################################################
if(transport_wan IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of libnddstransportwan
    set(transport_wan_libs
        "nddstransportwan"
        "nddstransporttls"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${transport_wan_libs}" "TRANSPORT_WAN")

    if(TRANSPORT_WAN_FOUND)
        set(RTIConnextDDS_transport_wan_FOUND TRUE)
    else()
        set(RTIConnextDDS_transport_wan_FOUND FALSE)
    endif()
endif()

#####################################################################
# Recording Service API Component Variables                         #
#####################################################################
if(recording_service IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of librtirecordingservicecore

    if(RTICONNEXTDDS_VERSION VERSION_GREATER_EQUAL "6.1.0")
        set(recording_service_libs "rtirecordingservicecore")
    else()
        set(recording_service_libs "rtirecordingservice")
    endif()

    list(APPEND recording_service_libs
        "rtiroutingservice"
        "rtirsinfrastructure"
        "nddscpp2"
        "rtidlc"
        "nddsmetp"
        "rticonnextmsgc"
        "rtixml2"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${recording_service_libs}"
        "RECORDING_SERVICE_API"
    )

    if(RECORDING_SERVICE_API_FOUND)
        set(RTIConnextDDS_recording_service_FOUND TRUE)
    else()
        set(RTIConnextDDS_recording_service_FOUND FALSE)
    endif()
endif()

#####################################################################
# Cloud Discovery Service API Component Variables                   #
#####################################################################

if(cloud_discovery_service IN_LIST RTIConnextDDS_FIND_COMPONENTS)

    set(cloud_discovery_service_api_c_libs
        "rticlouddiscoveryservice"
        "rtiroutingservice"
        "rtirsinfrastructure"
        "rtiapputilsc"
        "rtixml2"
        "nddsc"
        "nddscore"
        "rtidlc"
        "nddsmetp"
        "rtimonitoring"
        "rticonnextmsgc"
    )
    get_all_library_variables("${cloud_discovery_service_api_c_libs}"
        "CLOUD_DISCOVERY_SERVICE_API_C"
    )

    if(CLOUD_DISCOVERY_SERVICE_API_C_FOUND)
        if(WIN32 AND BUILD_SHARED_LIBS)
            list(APPEND CONNEXTDDS_DLL_EXPORT_MACRO
                "RTI_clouddiscoveryservice_core_DLL_VARIABLE"
            )
        endif()
        set(RTIConnextDDS_cloud_discovery_service_FOUND TRUE)
    else()
        set(RTIConnextDDS_cloud_discovery_service_FOUND FALSE)
    endif()
endif()

#####################################################################
# Persistence Service API Component Variables                       #
#####################################################################

if(persistence_service IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    set(persistence_service_api_c_libs
        "rtipersistenceservice"
        "nddsc"
        "nddscore"
        "rtidlc"
        "rtisqlite"
    )

    get_all_library_variables("${persistence_service_api_c_libs}"
        "PERSISTENCE_SERVICE_API_C"
    )

    if(PERSISTENCE_SERVICE_API_C_FOUND)
        if(WIN32 AND BUILD_SHARED_LIBS)
            list(APPEND CONNEXTDDS_DLL_EXPORT_MACRO
                "RTI_persistence_DLL_VARIABLE"
            )
        endif()
        set(RTIConnextDDS_persistence_service_FOUND TRUE)
    else()
        set(RTIConnextDDS_persistence_service_FOUND FALSE)
    endif()
endif()

#####################################################################
# Web Integration Service API Component Variables                   #
#####################################################################

if(web_integration_service IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    set(web_integration_service_api_cpp2_libs
        "rtiwebintegrationservice"
        "nddscore"
        "nddsc"
        "nddscpp"
        "nddscpp2"
        "rtiapputilsc"
        "rtisqlite"
    )
    get_all_library_variables("${web_integration_service_api_cpp2_libs}"
        "WEB_INTEGRATION_SERVICE_API_CPP2"
    )

    if(WEB_INTEGRATION_SERVICE_API_CPP2_FOUND)
        find_package(RTICivetweb REQUIRED)

        # Add civetweb library to the list of CONNEXTDDS_EXTERNAL_LIBS
        list(APPEND CONNEXTDDS_EXTERNAL_LIBS "${RTICivetweb-cpp_LIBRARY}")

        if(WIN32 AND BUILD_SHARED_LIBS)
            list(APPEND CONNEXTDDS_DLL_EXPORT_MACRO "RTI_wsdds_DLL_VARIABLE")
        endif()
        set(RTIConnextDDS_web_integration_service_FOUND TRUE)
    else()
        set(RTIConnextDDS_web_integration_service_FOUND FALSE)
    endif()
endif()

#####################################################################
# Low Bandwidth Pluggins Component Variables                        #
#####################################################################
if(low_bandwidth_plugins IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of libnddsdiscoverystatic
    set(discovery_static_libs
        "nddsdiscoverystatic"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables(
        "${discovery_static_libs}"
        "LOW_BANDWIDTH_DISCOVERY_STATIC"
    )

    # Find all flavors of librtilbedisc
    set(rtilbedisc_libs
        "rtilbedisc"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${rtilbedisc_libs}" "LOW_BANDWIDTH_EDISC")

    # Find all flavors of librtilbpdisc
    set(rtilbpdisc_libs
        "rtilbpdisc"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${rtilbpdisc_libs}" "LOW_BANDWIDTH_PDISC")

    # Find all flavors of librtilbrtps
    set(rtilbrtps_libs
        "rtilbrtps"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${rtilbrtps_libs}" "LOW_BANDWIDTH_RTPS")

    # Find all flavors of librtilbsm
    set(rtilbsm_libs
        "rtilbsm"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${rtilbsm_libs}" "LOW_BANDWIDTH_SM")

    # Find all flavors of librtilbst
    set(rtilbst_libs
        "rtilbst"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${rtilbst_libs}" "LOW_BANDWIDTH_ST")

    if(LOW_BANDWIDTH_DISCOVERY_STATIC_FOUND AND LOW_BANDWIDTH_EDISC_FOUND AND
            LOW_BANDWIDTH_PDISC_FOUND AND LOW_BANDWIDTH_RTPS_FOUND AND
            LOW_BANDWIDTH_SM_FOUND AND LOW_BANDWIDTH_ST_FOUND)
        set(RTIConnextDDS_low_bandwidth_plugins_FOUND TRUE)
    else()
        set(RTIConnextDDS_low_bandwidth_plugins_FOUND FALSE)
    endif()
endif()

#####################################################################
# rtizrtps Component Variables                                      #
#####################################################################
if(rtizrtps IN_LIST RTIConnextDDS_FIND_COMPONENTS)
    # Find all flavors of librtizrtps
    set(rtizrtps_libs
        "rtizrtps"
        "nddsc"
        "nddscore"
    )
    get_all_library_variables("${rtizrtps_libs}" "RTIZRTPS")

    if(RTIZRTPS_FOUND)
        set(RTIConnextDDS_rtizrtps_FOUND TRUE)
    else()
        set(RTIConnextDDS_rtizrtps_FOUND FALSE)
    endif()
endif()

#####################################################################
# Version checks                                                    #
#####################################################################
if(ENABLE_VERSION_CONSISTENCY_CHECK)
    # Verify that all the components specified have the same version
    file(READ "${CONNEXTDDS_DIR}/rti_versions.xml" xml_file)
    # Verify host components
    foreach(field IN LISTS rti_versions_field_names_host)
        connextdds_check_component_field_version(
            ${field}
            ${xml_file}
            connextdds_host_arch)
    endforeach()

    # Verify target components
    foreach(field IN LISTS rti_versions_field_names_target)
            connextdds_check_component_field_version(
                ${field}
                ${xml_file}
                CONNEXTDDS_ARCH
            )
    endforeach()
endif()

# Set CONNEXTDDS_DEFINITIONS for backward compatibility
foreach(definition ${CONNEXTDDS_COMPILE_DEFINITIONS})
    set(CONNEXTDDS_DEFINITIONS "${CONNEXTDDS_DEFINITIONS} -D${definition}")
endforeach()

# If there were not errors checking the version, everything was fine
if(NOT rtiversion_error)
    set(RTICONNEXTDDS_VERSION_OK TRUE)
endif()

include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(RTIConnextDDS
    REQUIRED_VARS
        CONNEXTDDS_DIR
        RTICONNEXTDDS_VERSION
        RTICONNEXTDDS_VERSION_OK
    VERSION_VAR
        RTICONNEXTDDS_VERSION
    HANDLE_COMPONENTS)

#####################################################################
# Create the imported targets                                       #
#####################################################################
if(RTIConnextDDS_FOUND)
    #################### Core and APIs imported targets #####################
    # Core
    create_connext_imported_target(
        TARGET "core"
        VAR "CONNEXTDDS_CORE"
        DEPENDENCIES
            ${CONNEXTDDS_EXTERNAL_LIBS}
    )

    set(target_definitions ${CONNEXTDDS_COMPILE_DEFINITIONS})
    if(BUILD_SHARED_LIBS)
        list(APPEND target_definitions
            ${CONNEXTDDS_DLL_EXPORT_MACRO}
        )
    else()
        # RTI_STATIC definition is used in security examples, but we define it
        # in the core imported target just in case it is spreaded to other
        # examples.
        list(APPEND target_definitions
            "RTI_STATIC"
        )
    endif()

    set_target_properties(RTIConnextDDS::core
        PROPERTIES
            INTERFACE_INCLUDE_DIRECTORIES
                "${CONNEXTDDS_INCLUDE_DIRS}"
            INTERFACE_LINK_DIRECTORIES
                "${CONNEXTDDS_DIR}/lib/${CONNEXTDDS_ARCH}"
            INTERFACE_COMPILE_DEFINITIONS
                "${target_definitions}"
            INTERFACE_COMPILE_OPTIONS
                "${CONNEXTDDS_COMPILE_OPTIONS}"
    )

    # C API
    create_connext_imported_target(
        TARGET "c_api"
        VAR "CONNEXTDDS_C_API"
        DEPENDENCIES
            RTIConnextDDS::core
    )

    # CPP API
    create_connext_imported_target(
        TARGET "cpp_api"
        VAR "CONNEXTDDS_CPP_API"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # Modern CPP API
    create_connext_imported_target(
        TARGET "cpp2_api"
        VAR "CONNEXTDDS_CPP2_API"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # Metp
    create_connext_imported_target(
        TARGET "metp"
        VAR "METP"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # RTIXML2
    create_connext_imported_target(
        TARGET "rtixml2"
        VAR "RTIXML2"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # RTIAPPUTILS_C
    create_connext_imported_target(
        TARGET "apputils_c"
        VAR "RTIAPPUTILS_C"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # RTISQLITE
    create_connext_imported_target(
        TARGET "rtisqlite"
        VAR "RTISQLITE"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    ######################## Test imported targets #########################

    create_connext_imported_target(
        TARGET "test"
        VAR "RTITEST"
    )

    create_connext_imported_target(
        TARGET "test_helpers"
        VAR "NDDS_TEST_HELPERS"
        DEPENDENCIES
            RTIConnextDDS::c_api
            RTIConnextDDS::test
    )

    ###################### Distributed Logger targets ######################
    # Distributed Logger C API
    create_connext_imported_target(
        TARGET "distributed_logger_c"
        VAR "DISTRIBUTED_LOGGER_C"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # Distributed Logger CPP API
    create_connext_imported_target(
        TARGET "distributed_logger_cpp"
        VAR "DISTRIBUTED_LOGGER_CPP"
        DEPENDENCIES
            RTIConnextDDS::distributed_logger_c
            RTIConnextDDS::cpp_api
    )

    # Distributed Logger CPP2 API
    create_connext_imported_target(
        TARGET "distributed_logger_cpp2"
        VAR "DISTRIBUTED_LOGGER_CPP2"
        DEPENDENCIES
            RTIConnextDDS::distributed_logger_c
            RTIConnextDDS::cpp2_api
    )

    ############## Messaging (Request-Reply) imported targets ###############
    # C Messaging API
    create_connext_imported_target(
        TARGET "messaging_c_api"
        VAR "MESSAGING_C_API"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # CPP Messaging API
    create_connext_imported_target(
        TARGET "messaging_cpp_api"
        VAR "MESSAGING_CPP_API"
        DEPENDENCIES
            RTIConnextDDS::cpp_api
    )

    # Modern CPP Messaging API
    create_connext_imported_target(
        TARGET "messaging_cpp2_api"
        VAR "MESSAGING_CPP2_API"
        DEPENDENCIES
            RTIConnextDDS::cpp2_api
    )


    ################## Security plugins imported targets ###################
    # Security plugins
    set(dependencies RTIConnextDDS::c_api)

    # The OpenSSL and wolfSSL imported targets are created by
    # find_package(OpenSSL|wolfSSL). We ensure not linking against OpenSSL if
    # wolfSSL is found to avoid problems. This could happen if we first search
    # for OpenSSL and then call the FindPackage asking for Wolf.
    if(TARGET wolfSSL::wolfSSL)
        list(APPEND dependencies
            wolfSSL::wolfSSL
        )
    else()
        if(TARGET OpenSSL::SSL)
            list(APPEND dependencies
                OpenSSL::SSL
            )
        endif()
        if(TARGET OpenSSL::Crypto)
            list(APPEND dependencies
                OpenSSL::Crypto
            )
        endif()
    endif()

    create_connext_imported_target(
        TARGET "security_plugins"
        VAR "SECURITY_PLUGINS"
        DEPENDENCIES
            ${dependencies}
    )


    ################ Monitoring libraries imported targets ##################
    create_connext_imported_target(
        TARGET "monitoring"
        VAR "MONITORING"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )


    ###################### Transports imported targets ######################
    # TLS library
    create_connext_imported_target(
        TARGET "nddstls"
        VAR "NDDSTLS"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # TCP
    create_connext_imported_target(
        TARGET "transport_tcp"
        VAR "TRANSPORT_TCP"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # Transport TLS
    create_connext_imported_target(
        TARGET "transport_tls"
        VAR "TRANSPORT_TLS"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # Transport WAN
    create_connext_imported_target(
        TARGET "transport_wan"
        VAR "TRANSPORT_WAN"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )


    ######################## Low bandwidth plugins #########################
    # Discovery Static
    create_connext_imported_target(
        TARGET "low_bandwidth_discovery_static"
        VAR "LOW_BANDWIDTH_DISCOVERY_STATIC"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # EDISC
    create_connext_imported_target(
        TARGET "low_bandwidth_edisc"
        VAR "LOW_BANDWIDTH_EDISC"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # PDISC
    create_connext_imported_target(
        TARGET "low_bandwidth_pdisc"
        VAR "LOW_BANDWIDTH_PDISC"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # RTPS
    create_connext_imported_target(
        TARGET "low_bandwidth_rtps"
        VAR "LOW_BANDWIDTH_RTPS"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # SM
    create_connext_imported_target(
        TARGET "low_bandwidth_sm"
        VAR "LOW_BANDWIDTH_SM"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # ST
    create_connext_imported_target(
        TARGET "low_bandwidth_st"
        VAR "LOW_BANDWIDTH_ST"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    # RTIZRTPS
    create_connext_imported_target(
        TARGET "rtirtps"
        VAR "RTIZRTPS"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )


    ####################### Services imported targets #######################
    # Infrastructure
    create_connext_imported_target(
        TARGET "routing_service_infrastructure"
        VAR "ROUTING_SERVICE_INFRASTRUCTURE"
        DEPENDENCIES
            RTIConnextDDS::c_api
    )

    create_connext_imported_target(
        TARGET "service_admin_cpp2"
        VAR "ROUTING_SERVICE_ADMIN"
        DEPENDENCIES
            RTIConnextDDS::cpp2_api
    )

    # Routing Service C API
    set(dependencies RTIConnextDDS::routing_service_infrastructure)

    if(TARGET RTIConnextDDS::distributed_logger_c)
        list(APPEND dependencies
            RTIConnextDDS::distributed_logger_c
        )
    endif()

    if(TARGET RTIConnextDDS::metp)
        list(APPEND dependencies
            RTIConnextDDS::metp
        )
    endif()

    if(TARGET RTIConnextDDS::messaging_c_api)
        list(APPEND dependencies
            RTIConnextDDS::messaging_c_api
        )
    endif()

    if(TARGET RTIConnextDDS::rtixml2)
        list(APPEND dependencies
            RTIConnextDDS::rtixml2
        )
    endif()

    if(TARGET RTIConnextDDS::apputils_c)
        list(APPEND dependencies
            RTIConnextDDS::apputils_c
        )
    endif()

    create_connext_imported_target(
        TARGET "routing_service_c"
        VAR "ROUTING_SERVICE_API"
        DEPENDENCIES
            ${dependencies}
    )

    # We create a similar target to the Routing Service C API but with another
    # nombre for backward compatibility
    create_connext_imported_target(
        TARGET "routing_service"
        VAR "ROUTING_SERVICE_API"
        DEPENDENCIES
            ${dependencies}
    )

    # The Routing Service CPP libraries are the C libraries + the CPP API
    create_connext_imported_target(
        TARGET "routing_service_cpp"
        VAR "ROUTING_SERVICE_API"
        DEPENDENCIES
            RTIConnextDDS::routing_service_c
            RTIConnextDDS::cpp_api
    )

    # The Routing Service CPP2 libraries are the C libraries + the CPP2 API
    create_connext_imported_target(
        TARGET "routing_service_cpp2"
        VAR "ROUTING_SERVICE_API"
        DEPENDENCIES
            RTIConnextDDS::routing_service_c
            RTIConnextDDS::cpp2_api
    )

    # Routing Service Assign Transformation
    create_connext_imported_target(
        TARGET "assign_transformation"
        VAR "ASSIGN_TRANSFORMATION"
        DEPENDENCIES
            RTIConnextDDS::routing_service_c
    )

    # Recording Service
    create_connext_imported_target(
        TARGET "recording_service"
        VAR "RECORDING_SERVICE_API"
        DEPENDENCIES
            RTIConnextDDS::routing_service_c
            RTIConnextDDS::routing_service_infrastructure
            RTIConnextDDS::cpp2_api
    )

    # Cloud Discovery Service
    create_connext_imported_target(
        TARGET "cloud_discovery_service_c"
        VAR "CLOUD_DISCOVERY_SERVICE_API_C"
        DEPENDENCIES
            RTIConnextDDS::routing_service_c
    )

    # Cloud Discovery Service CPP libraries are the C libraries + the CPP API
    create_connext_imported_target(
        TARGET "cloud_discovery_service_cpp2"
        VAR "CLOUD_DISCOVERY_SERVICE_API_C"
        DEPENDENCIES
            RTIConnextDDS::cloud_discovery_service_c
            RTIConnextDDS::cpp2_api
    )

    # Persistence Service C API
    create_connext_imported_target(
        TARGET "persistence_service_c"
        VAR "PERSISTENCE_SERVICE_API_C"
        DEPENDENCIES
            RTIConnextDDS::distributed_logger_c
            RTIConnextDDS::rtisqlite
    )

    # Web Integration Service CPP API
    create_connext_imported_target(
        TARGET "web_integration_service_cpp2"
        VAR "WEB_INTEGRATION_SERVICE_API_CPP2"
        DEPENDENCIES
            RTIConnextDDS::cpp_api
            RTIConnextDDS::cpp2_api
            RTIConnextDDS::apputils_c
            RTIConnextDDS::rtisqlite
            RTICivetweb::civetweb-cpp
    )
endif()