# Copyright The OpenTelemetry Authors # SPDX-License-Identifier: Apache-2.0 include("${PROJECT_SOURCE_DIR}/cmake/thirdparty-dependency-config.cmake") ######################################################################## # INTERNAL FUNCTIONS - do not call directly. Use the otel_* "Main" functions ######################################################################## #----------------------------------------------------------------------- # _otel_set_component_properties: # Sets the component properties used for install. # Properties set on PROJECT_SOURCE_DIR directory include: # OTEL_COMPONENTS_LIST: List of components added using otel_add_component # OTEL_COMPONENT_TARGETS_: List of targets associated with the component # OTEL_COMPONENT_TARGETS_ALIAS_: List of targets aliases associated with the component # OTEL_COMPONENT_FILES_DIRECTORY_: Directory containing files to be installed with the component # OTEL_COMPONENT_FILES_DESTINATION_: Destination directory for the files # OTEL_COMPONENT_FILES_MATCHING_: Matching pattern for the files to be installed # OTEL_COMPONENT_DEPENDS_: List of components that this component depends on # OTEL_COMPONENT_THIRDPARTY_DEPENDS_: List of thirdparty dependencies that this component depends on #----------------------------------------------------------------------- function(_otel_set_component_properties) set(optionArgs ) set(oneValueArgs COMPONENT FILES_DIRECTORY FILES_DESTINATION) set(multiValueArgs TARGETS TARGETS_ALIAS FILES_MATCHING COMPONENT_DEPENDS THIRDPARTY_DEPENDS) cmake_parse_arguments(_PROPERTIES "${optionArgs}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}") # Add the component to the current components list get_property(existing_components DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENTS_LIST) if(_PROPERTIES_COMPONENT IN_LIST existing_components) message(FATAL_ERROR " component ${_PROPERTIES_COMPONENT} has already been created.") endif() list(APPEND existing_components "${_PROPERTIES_COMPONENT}") set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENTS_LIST "${existing_components}") # Set the component targets property if(_PROPERTIES_TARGETS) set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_TARGETS_${_PROPERTIES_COMPONENT} "${_PROPERTIES_TARGETS}") else() message(FATAL_ERROR " component ${_PROPERTIES_COMPONENT} does not have any targets.") endif() # Set the component targets alias property if(_PROPERTIES_TARGETS_ALIAS) set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_TARGETS_ALIAS_${_PROPERTIES_COMPONENT} "${_PROPERTIES_TARGETS_ALIAS}") endif() # Set the component files property if(_PROPERTIES_FILES_DIRECTORY) if(NOT _PROPERTIES_FILES_DESTINATION) message(FATAL_ERROR " component ${_PROPERTIES_COMPONENT} has FILES_DIRECTORY set and must have FILES_DESINATION set.") endif() if(NOT _PROPERTIES_FILES_MATCHING) message(FATAL_ERROR " component ${_PROPERTIES_COMPONENT} has FILES_DIRECTORY set and must have FILES_MATCHING set.") endif() set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_FILES_DIRECTORY_${_PROPERTIES_COMPONENT} "${_PROPERTIES_FILES_DIRECTORY}") set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_FILES_DESTINATION_${_PROPERTIES_COMPONENT} "${_PROPERTIES_FILES_DESTINATION}") set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_FILES_MATCHING_${_PROPERTIES_COMPONENT} "${_PROPERTIES_FILES_MATCHING}") endif() if(_PROPERTIES_COMPONENT_DEPENDS) set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_DEPENDS_${_PROPERTIES_COMPONENT} "${_PROPERTIES_COMPONENT_DEPENDS}") endif() if(_PROPERTIES_THIRDPARTY_DEPENDS) set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_THIRDPARTY_DEPENDS_${_PROPERTIES_COMPONENT} "${_PROPERTIES_THIRDPARTY_DEPENDS}") endif() endfunction() #----------------------------------------------------------------------- # _otel_set_target_component_property: # Sets the target's INTERFACE_OTEL_COMPONENT_NAME property to the component. # A target can only be assigned to one component. # Note: The INTERFACE_* prefix can be dropped with CMake 3.19+ when custom # properties without the prefix are supported on INTERFACE targets. #----------------------------------------------------------------------- function(_otel_set_target_component_property _TARGET _COMPONENT) get_target_property(_TARGET_COMPONENT ${_TARGET} INTERFACE_OTEL_COMPONENT_NAME) if(_TARGET_COMPONENT) message(FATAL_ERROR " Target ${_TARGET} is already assigned to an opentelemetry-cpp COMPONENT ${_TARGET_COMPONENT}.") endif() set_target_properties(${_TARGET} PROPERTIES INTERFACE_OTEL_COMPONENT_NAME ${_OTEL_ADD_COMP_COMPONENT}) endfunction() #----------------------------------------------------------------------- # _otel_append_dependent_components: # Appends the dependent component to the OUT_COMPONENTS variable. # The dependent component is defined in the OTEL_COMPONENT_DEPENDS_ property # on the PROJECT_SOURCE_DIR directory. #----------------------------------------------------------------------- function(_otel_append_dependent_components _COMPONENT OUT_COMPONENTS) get_property(_COMPONENT_DEPENDS DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_DEPENDS_${_COMPONENT}) if(_COMPONENT_DEPENDS) set(_output_components "${${OUT_COMPONENTS}}") message(DEBUG " - adding dependent component ${_COMPONENT_DEPENDS} from component ${_COMPONENT}") list(APPEND _output_components ${_COMPONENT_DEPENDS}) set(${OUT_COMPONENTS} "${_output_components}" PARENT_SCOPE) endif() endfunction() #----------------------------------------------------------------------- # _otel_append_component_found: # Checks if the target is associated with an otel component using the INTERFACE_OTEL_COMPONENT_NAME target property. # If so then the component is appended to the OUT_COMPONENTS varaiable. #----------------------------------------------------------------------- function(_otel_append_component_found _COMPONENT _TARGET OUT_COMPONENTS OUT_COMPONENT_FOUND) set(_output_components "${${OUT_COMPONENTS}}") get_target_property(_DEPEND_COMPONENT ${_TARGET} INTERFACE_OTEL_COMPONENT_NAME) if(_DEPEND_COMPONENT AND NOT ${_DEPEND_COMPONENT} STREQUAL ${_COMPONENT}) _otel_append_dependent_components(${_DEPEND_COMPONENT} _output_components) message(DEBUG " - adding dependent component ${_DEPEND_COMPONENT} from target ${_TARGET}") list(APPEND _output_components ${_DEPEND_COMPONENT}) set(${OUT_COMPONENT_FOUND} TRUE PARENT_SCOPE) else() set(${OUT_COMPONENT_FOUND} FALSE PARENT_SCOPE) endif() set(${OUT_COMPONENTS} "${_output_components}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------- # _otel_append_thirdparty_found: # Tries to match one of the supported third-party dependencies to the target name. # If found the dependency project name is appended to the OUT_THIRDPARTY_DEPS variable. # The match is based on the OTEL_THIRDPARTY_DEPENDENCIES_SUPPORTED list and optional # OTEL__TARGET_NAMESPACE variables. #------------------------------------------------------------------------ function(_otel_append_thirdparty_found _TARGET OUT_THIRDPARTY_DEPS) set(_output_thirdparty_deps "${${OUT_THIRDPARTY_DEPS}}") foreach(_DEPENDENCY ${OTEL_THIRDPARTY_DEPENDENCIES_SUPPORTED}) # Search for the dependency namespace in the target name if(NOT "${OTEL_${_DEPENDENCY}_TARGET_NAMESPACE}" STREQUAL "") set(_DEPENDENCY_NAMESPACE "${OTEL_${_DEPENDENCY}_TARGET_NAMESPACE}") else() set(_DEPENDENCY_NAMESPACE "${_DEPENDENCY}") endif() string(FIND "${_TARGET}" "${_DEPENDENCY_NAMESPACE}" _is_thirdparty) if(_is_thirdparty GREATER -1) message(DEBUG " - adding thirdparty dependency ${_DEPENDENCY} from target ${_TARGET}") list(APPEND _output_thirdparty_deps ${_DEPENDENCY}) endif() endforeach() set(${OUT_THIRDPARTY_DEPS} "${_output_thirdparty_deps}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------- # _otel_collect_component_dependencies: # Collects the component to component dependencies and thirdparty dependencies of a target. # The dependencies are collected from the target's LINK_LIBRARIES property# and are appended # to the OUT_COMPONENT_DEPS and OUT_THIRDPARTY_DEPS variables. #------------------------------------------------------------------------ function(_otel_collect_component_dependencies _TARGET _COMPONENT OUT_COMPONENT_DEPS OUT_THIRDPARTY_DEPS) get_target_property(_TARGET_TYPE ${_TARGET} TYPE) message(DEBUG " Target: ${_TARGET} - Type: ${_TARGET_TYPE}") # Set the linked libraries to search for dependencies set(_linked_libraries "") if(_TARGET_TYPE STREQUAL "INTERFACE_LIBRARY") get_target_property(_interface_libs ${_TARGET} INTERFACE_LINK_LIBRARIES) set(_linked_libraries "${_interface_libs}") message(DEBUG " - INTERFACE_LINK_LIBRARIES: ${_interface_libs}") else() get_target_property(_link_libs ${_TARGET} LINK_LIBRARIES) set(_linked_libraries "${_link_libs}") message(DEBUG " - LINK_LIBRARIES: ${_link_libs}") endif() set(_component_deps "${${OUT_COMPONENT_DEPS}}") set(_thirdparty_deps "${${OUT_THIRDPARTY_DEPS}}") foreach(_linked_target ${_linked_libraries}) # Handle targets if(TARGET "${_linked_target}") set(_component_found FALSE) _otel_append_component_found(${_COMPONENT} "${_linked_target}" _component_deps _component_found) if(NOT ${_component_found}) _otel_append_thirdparty_found(${_linked_target} _thirdparty_deps) endif() continue() endif() # Skip BUILD_INTERFACE targets string(FIND "${_linked_target}" "$ #------------------------------------------------------------------------ function(_otel_add_target_alias _TARGET OUT_ALIAS_TARGETS) get_target_property(_TARGET_EXPORT_NAME ${_TARGET} EXPORT_NAME) if(NOT _TARGET_EXPORT_NAME) message(FATAL_ERROR " Target ${_TARGET} does not have an EXPORT_NAME property.") elseif(NOT TARGET "${PROJECT_NAME}::${_TARGET_EXPORT_NAME}") add_library("${PROJECT_NAME}::${_TARGET_EXPORT_NAME}" ALIAS ${_TARGET}) endif() set(_alias_targets "${${OUT_ALIAS_TARGETS}}") list(APPEND _alias_targets "${PROJECT_NAME}::${_TARGET_EXPORT_NAME}") set(${OUT_ALIAS_TARGETS} "${_alias_targets}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------- # _otel_install_component: # Installs the component targets and optional files #----------------------------------------------------------------------- function(_otel_install_component _COMPONENT) install( TARGETS ${_COMPONENT_TARGETS} EXPORT "${PROJECT_NAME}-${_COMPONENT}-target" RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT ${_COMPONENT}) install( EXPORT "${PROJECT_NAME}-${_COMPONENT}-target" FILE "${PROJECT_NAME}-${_COMPONENT}-target.cmake" NAMESPACE "${PROJECT_NAME}::" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" COMPONENT ${_COMPONENT}) if(_COMPONENT_FILES_DIRECTORY) install( DIRECTORY ${_COMPONENT_FILES_DIRECTORY} DESTINATION ${_COMPONENT_FILES_DESTINATION} COMPONENT ${_COMPONENT} FILES_MATCHING ${_COMPONENT_FILES_MATCHING}) endif() endfunction() #----------------------------------------------------------------------- # _otel_populate_component_targets_block: # Populates the OTEL_COMPONENTS_TARGETS_BLOCK with the component targets # - sets COMPONENT__TARGETS variables #----------------------------------------------------------------------- function(_otel_populate_component_targets_block IN_COMPONENT COMPONENTS_TARGETS_BLOCK) # Populate OTEL_COMPONENTS_TARGETS_BLOCK set(_targets_block ${${COMPONENTS_TARGETS_BLOCK}}) string(APPEND _targets_block "# COMPONENT ${IN_COMPONENT}\n" "set(COMPONENT_${IN_COMPONENT}_TARGETS\n" ) foreach(_TARGET IN LISTS _COMPONENT_TARGETS_ALIAS) string(APPEND _targets_block " ${_TARGET}\n") endforeach() string(APPEND _targets_block ")\n\n") set(${COMPONENTS_TARGETS_BLOCK} "${_targets_block}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------- # _otel_populate_component_internal_depends_block: # Populates the OTEL_COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK with the component dependencies # - sets COMPONENT__COMPONENT_DEPENDS variables #----------------------------------------------------------------------- function(_otel_populate_component_internal_depends_block IN_COMPONENT COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK) # Populate OTEL_COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK set(_deps_block ${${COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK}}) string(APPEND _deps_block "# COMPONENT ${IN_COMPONENT} internal dependencies\n" "set(COMPONENT_${IN_COMPONENT}_COMPONENT_DEPENDS\n" ) foreach(dep IN LISTS _COMPONENT_DEPENDS) string(APPEND _deps_block " ${dep}\n") endforeach() string(APPEND _deps_block ")\n\n") set(${COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK} "${_deps_block}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------- function(_otel_populate_component_thirdparty_depends_block IN_COMPONENT COMPONENTS_THIRDPARTY_DEPENDENCIES_BLOCK) # Populate OTEL_COMPONENTS_THIRDPARTY_DEPENDENCIES_BLOCK set(_deps_block ${${COMPONENTS_THIRDPARTY_DEPENDENCIES_BLOCK}}) string(APPEND _deps_block "# COMPONENT ${IN_COMPONENT} thirdparty dependencies\n" "set(COMPONENT_${IN_COMPONENT}_THIRDPARTY_DEPENDS\n" ) foreach(dep IN LISTS _COMPONENT_THIRDPARTY_DEPENDS) string(APPEND _deps_block " ${dep}\n") endforeach() string(APPEND _deps_block ")\n\n") set(${COMPONENTS_THIRDPARTY_DEPENDENCIES_BLOCK} "${_deps_block}" PARENT_SCOPE) endfunction() #----------------------------------------------------------------------- ######################################################################## # Main functions to support installing components # and the opentlemetry-cpp cmake package config files ######################################################################## #----------------------------------------------------------------------- # otel_add_component: # Adds a component to the list of components to be installed. A component name and list of targest are required. # Optional files can be added to the component by specifying a directory, destination and matching pattern. # Each target is assigned to the component and its dependencies are identified based on the LINK_LIBRARIES property. # An alias target is also created for each target in the form of PROJECT_NAME::TARGET_EXPORT_NAME. # Usage: # otel_add_component( # COMPONENT # TARGETS ... # FILES_DIRECTORY # FILES_DESTINATION # FILES_MATCHING ) #----------------------------------------------------------------------- function(otel_add_component) set(optionArgs ) set(oneValueArgs COMPONENT FILES_DIRECTORY FILES_DESTINATION) set(multiValueArgs TARGETS FILES_MATCHING) cmake_parse_arguments(_OTEL_ADD_COMP "${optionArgs}" "${oneValueArgs}" "${multiValueArgs}" "${ARGN}") if(NOT _OTEL_ADD_COMP_COMPONENT) message(FATAL_ERROR "otel_add_component: COMPONENT is required") endif() if(NOT _OTEL_ADD_COMP_TARGETS) message(FATAL_ERROR "otel_add_component: TARGETS is required") endif() message(DEBUG "Add COMPONENT: ${_OTEL_ADD_COMP_COMPONENT}") set(_COMPONENT_DEPENDS "") set(_THIRDPARTY_DEPENDS "") set(_ALIAS_TARGETS "") foreach(_TARGET ${_OTEL_ADD_COMP_TARGETS}) if(NOT TARGET ${_TARGET}) message(FATAL_ERROR " Target ${_TARGET} not found") endif() _otel_set_target_component_property(${_TARGET} ${_OTEL_ADD_COMP_COMPONENT}) _otel_collect_component_dependencies(${_TARGET} ${_OTEL_ADD_COMP_COMPONENT} _COMPONENT_DEPENDS _THIRDPARTY_DEPENDS) _otel_add_target_alias(${_TARGET} _ALIAS_TARGETS) endforeach() if(_OTEL_ADD_COMP_FILES_DIRECTORY) set(_OTEL_ADD_COMP_FILES_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/${_OTEL_ADD_COMP_FILES_DIRECTORY}") endif() message(DEBUG " TARGETS: ${_OTEL_ADD_COMP_TARGETS}") message(DEBUG " TARGETS_ALIAS: ${_ALIAS_TARGETS}") message(DEBUG " COMPONENT_DEPENDS: ${_COMPONENT_DEPENDS}") message(DEBUG " THIRDPARTY_DEPENDS: ${_THIRDPARTY_DEPENDS}") message(DEBUG " FILES_DIRECTORY: ${_OTEL_ADD_COMP_FILES_DIRECTORY}") message(DEBUG " FILES_DESTINATION: ${_OTEL_ADD_COMP_FILES_DESTINATION}") message(DEBUG " FILES_MATCHING: ${_OTEL_ADD_COMP_FILES_MATCHING}") _otel_set_component_properties( COMPONENT ${_OTEL_ADD_COMP_COMPONENT} TARGETS ${_OTEL_ADD_COMP_TARGETS} TARGETS_ALIAS ${_ALIAS_TARGETS} FILES_DIRECTORY ${_OTEL_ADD_COMP_FILES_DIRECTORY} FILES_DESTINATION ${_OTEL_ADD_COMP_FILES_DESTINATION} FILES_MATCHING ${_OTEL_ADD_COMP_FILES_MATCHING} COMPONENT_DEPENDS ${_COMPONENT_DEPENDS} THIRDPARTY_DEPENDS ${_THIRDPARTY_DEPENDS}) endfunction() #----------------------------------------------------------------------- # otel_install_components: # Installs all components that have been added using otel_add_component. # The components are installed in the order they were added. # The install function will create a cmake config file for each component # that contains the component name, targets, dependencies and thirdparty dependencies. # Usage: # otel_install_components() #----------------------------------------------------------------------- function(otel_install_components) get_property(OTEL_BUILT_COMPONENTS_LIST DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENTS_LIST) message(STATUS "Installing components:") set(OTEL_COMPONENTS_TARGETS_BLOCK "") set(OTEL_COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK "") set(OTEL_COMPONENTS_THIRDPARTY_DEPENDENCIES_BLOCK "") foreach(_COMPONENT ${OTEL_BUILT_COMPONENTS_LIST}) get_property(_COMPONENT_DEPENDS DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_DEPENDS_${_COMPONENT}) get_property(_COMPONENT_TARGETS DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_TARGETS_${_COMPONENT}) get_property(_COMPONENT_TARGETS_ALIAS DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_TARGETS_ALIAS_${_COMPONENT}) get_property(_COMPONENT_THIRDPARTY_DEPENDS DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_THIRDPARTY_DEPENDS_${_COMPONENT}) get_property(_COMPONENT_FILES_DIRECTORY DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_FILES_DIRECTORY_${_COMPONENT}) get_property(_COMPONENT_FILES_DESTINATION DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_FILES_DESTINATION_${_COMPONENT}) get_property(_COMPONENT_FILES_MATCHING DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY OTEL_COMPONENT_FILES_MATCHING_${_COMPONENT}) message(STATUS "Install COMPONENT ${_COMPONENT}") message(STATUS " TARGETS: ${_COMPONENT_TARGETS}") message(STATUS " TARGETS_ALIAS: ${_COMPONENT_TARGETS_ALIAS}") message(STATUS " COMPONENT_DEPENDS: ${_COMPONENT_DEPENDS}") message(STATUS " THIRDPARTY_DEPENDS: ${_COMPONENT_THIRDPARTY_DEPENDS}") message(STATUS " FILES_DIRECTORY: ${_COMPONENT_FILES_DIRECTORY}") message(STATUS " FILES_DESTINATION: ${_COMPONENT_FILES_DESTINATION}") message(STATUS " FILES_MATCHING: ${_COMPONENT_FILES_MATCHING}") _otel_install_component(${_COMPONENT}) _otel_populate_component_targets_block(${_COMPONENT} OTEL_COMPONENTS_TARGETS_BLOCK) _otel_populate_component_internal_depends_block(${_COMPONENT} OTEL_COMPONENTS_INTERNAL_DEPENDENCIES_BLOCK) _otel_populate_component_thirdparty_depends_block(${_COMPONENT} OTEL_COMPONENTS_THIRDPARTY_DEPENDENCIES_BLOCK) endforeach() configure_file( "${PROJECT_SOURCE_DIR}/cmake/templates/component-definitions.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake/component-definitions.cmake" @ONLY ) install( FILES "${CMAKE_CURRENT_BINARY_DIR}/cmake/component-definitions.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" COMPONENT cmake-config) endfunction() #----------------------------------------------------------------------- # otel_install_thirdparty_definitions: # Installs the thirdparty dependency definitions file that contains the list # of thirdparty dependencies their versions and cmake search modes. # - sets `OTEL_THIRDPARTY_DEPENDENCIES_SUPPORTED` to the list of dependencies # - sets `OTEL__VERSION` to the version used to build opentelemetry-cpp # - sets `OTEL__SEARCH_MODE` to the search mode required to find the dependency # Usage: # otel_install_thirdparty_definitions() #----------------------------------------------------------------------- function(otel_install_thirdparty_definitions) set(OTEL_THIRDPARTY_DEPENDENCY_VERSIONS_BLOCK "") set(OTEL_THIRDPARTY_DEPENDENCY_SEARCH_MODES_BLOCK "") # Populate OTEL_THIRDPARTY_DEPENDENCY_VERSIONS_BLOCK foreach(_DEPENDENCY ${OTEL_THIRDPARTY_DEPENDENCIES_SUPPORTED}) string(APPEND OTEL_THIRDPARTY_DEPENDENCY_VERSIONS_BLOCK "set(OTEL_${_DEPENDENCY}_VERSION \"${${_DEPENDENCY}_VERSION}\")\n" ) endforeach() # Populate OTEL_THIRDPARTY_DEPENDENCY_SEARCH_MODES_BLOCK foreach(_DEPENDENCY ${OTEL_THIRDPARTY_DEPENDENCIES_SUPPORTED}) string(APPEND OTEL_THIRDPARTY_DEPENDENCY_SEARCH_MODES_BLOCK "set(OTEL_${_DEPENDENCY}_SEARCH_MODE \"${OTEL_${_DEPENDENCY}_SEARCH_MODE}\")\n" ) endforeach() configure_file( "${PROJECT_SOURCE_DIR}/cmake/templates/thirdparty-dependency-definitions.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake/thirdparty-dependency-definitions.cmake" @ONLY) install( FILES "${CMAKE_CURRENT_BINARY_DIR}/cmake/thirdparty-dependency-definitions.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" COMPONENT cmake-config) endfunction() #----------------------------------------------------------------------- # otel_install_cmake_config: # Configures and installs the cmake.config package file and version file # to support find_package(opentelemetry-cpp CONFIG COMPONENTS ...) # Usage: # otel_install_cmake_config() #----------------------------------------------------------------------- function(otel_install_cmake_config) # Write config file for find_package(opentelemetry-cpp CONFIG) set(INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_INCLUDEDIR}") configure_package_config_file( "${PROJECT_SOURCE_DIR}/cmake/templates/opentelemetry-cpp-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config.cmake" INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" PATH_VARS OPENTELEMETRY_ABI_VERSION_NO OPENTELEMETRY_VERSION PROJECT_NAME INCLUDE_INSTALL_DIR CMAKE_INSTALL_LIBDIR) # Write version file for find_package(opentelemetry-cpp CONFIG) write_basic_package_version_file( "${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config-version.cmake" VERSION ${OPENTELEMETRY_VERSION} COMPATIBILITY ExactVersion) install( FILES "${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config.cmake" "${CMAKE_CURRENT_BINARY_DIR}/cmake/${PROJECT_NAME}/${PROJECT_NAME}-config-version.cmake" "${CMAKE_CURRENT_LIST_DIR}/cmake/find-package-support-functions.cmake" DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}" COMPONENT cmake-config) endfunction()